k8s.io/kubernetes@v1.31.0-alpha.0.0.20240520171757-56147500dadc/pkg/registry/core/service/storage/storage_test.go (about) 1 /* 2 Copyright 2015 The Kubernetes Authors. 3 4 Licensed under the Apache License, Version 2.0 (the "License"); 5 you may not use this file except in compliance with the License. 6 You may obtain a copy of the License at 7 8 http://www.apache.org/licenses/LICENSE-2.0 9 10 Unless required by applicable law or agreed to in writing, software 11 distributed under the License is distributed on an "AS IS" BASIS, 12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 See the License for the specific language governing permissions and 14 limitations under the License. 15 */ 16 17 package storage 18 19 import ( 20 "context" 21 "fmt" 22 "net" 23 "reflect" 24 stdruntime "runtime" 25 "strings" 26 "testing" 27 28 "github.com/google/go-cmp/cmp" 29 "github.com/google/go-cmp/cmp/cmpopts" 30 "k8s.io/apimachinery/pkg/api/errors" 31 metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" 32 "k8s.io/apimachinery/pkg/fields" 33 "k8s.io/apimachinery/pkg/labels" 34 "k8s.io/apimachinery/pkg/runtime" 35 "k8s.io/apimachinery/pkg/runtime/schema" 36 "k8s.io/apimachinery/pkg/util/intstr" 37 machineryutilnet "k8s.io/apimachinery/pkg/util/net" 38 genericapirequest "k8s.io/apiserver/pkg/endpoints/request" 39 "k8s.io/apiserver/pkg/registry/generic" 40 genericregistrytest "k8s.io/apiserver/pkg/registry/generic/testing" 41 "k8s.io/apiserver/pkg/registry/rest" 42 etcd3testing "k8s.io/apiserver/pkg/storage/etcd3/testing" 43 utilfeature "k8s.io/apiserver/pkg/util/feature" 44 featuregatetesting "k8s.io/component-base/featuregate/testing" 45 epstest "k8s.io/kubernetes/pkg/api/endpoints/testing" 46 svctest "k8s.io/kubernetes/pkg/api/service/testing" 47 api "k8s.io/kubernetes/pkg/apis/core" 48 "k8s.io/kubernetes/pkg/features" 49 endpointstore "k8s.io/kubernetes/pkg/registry/core/endpoint/storage" 50 podstore "k8s.io/kubernetes/pkg/registry/core/pod/storage" 51 "k8s.io/kubernetes/pkg/registry/core/service/ipallocator" 52 "k8s.io/kubernetes/pkg/registry/core/service/portallocator" 53 "k8s.io/kubernetes/pkg/registry/registrytest" 54 netutils "k8s.io/utils/net" 55 ) 56 57 // Most tests will use this to create a registry to run tests against. 58 func newStorage(t *testing.T, ipFamilies []api.IPFamily) (*wrapperRESTForTests, *StatusREST, *etcd3testing.EtcdTestServer) { 59 return newStorageWithPods(t, ipFamilies, nil, nil) 60 } 61 62 func newStorageWithPods(t *testing.T, ipFamilies []api.IPFamily, pods []api.Pod, endpoints []*api.Endpoints) (*wrapperRESTForTests, *StatusREST, *etcd3testing.EtcdTestServer) { 63 etcdStorage, server := registrytest.NewEtcdStorage(t, "") 64 restOptions := generic.RESTOptions{ 65 StorageConfig: etcdStorage.ForResource(schema.GroupResource{Resource: "services"}), 66 Decorator: generic.UndecoratedStorage, 67 DeleteCollectionWorkers: 1, 68 ResourcePrefix: "services", 69 } 70 71 ipAllocs := map[api.IPFamily]ipallocator.Interface{} 72 for _, fam := range ipFamilies { 73 switch fam { 74 case api.IPv4Protocol: 75 _, cidr, _ := netutils.ParseCIDRSloppy("10.0.0.0/16") 76 ipAllocs[fam] = makeIPAllocator(cidr) 77 case api.IPv6Protocol: 78 _, cidr, _ := netutils.ParseCIDRSloppy("2000::/108") 79 ipAllocs[fam] = makeIPAllocator(cidr) 80 default: 81 t.Fatalf("Unknown IPFamily: %v", fam) 82 } 83 } 84 85 portAlloc := makePortAllocator(*(machineryutilnet.ParsePortRangeOrDie("30000-32767"))) 86 87 // Not all tests will specify pods and endpoints. 88 podStorage, err := podstore.NewStorage(generic.RESTOptions{ 89 StorageConfig: etcdStorage, 90 Decorator: generic.UndecoratedStorage, 91 DeleteCollectionWorkers: 3, 92 ResourcePrefix: "pods", 93 }, nil, nil, nil) 94 if err != nil { 95 t.Fatalf("unexpected error from REST storage: %v", err) 96 } 97 if pods != nil && len(pods) > 0 { 98 ctx := genericapirequest.NewDefaultContext() 99 for ix := range pods { 100 key, _ := podStorage.Pod.KeyFunc(ctx, pods[ix].Name) 101 if err := podStorage.Pod.Storage.Create(ctx, key, &pods[ix], nil, 0, false); err != nil { 102 t.Fatalf("Couldn't create pod: %v", err) 103 } 104 } 105 } 106 107 endpointsStorage, err := endpointstore.NewREST(generic.RESTOptions{ 108 StorageConfig: etcdStorage, 109 Decorator: generic.UndecoratedStorage, 110 ResourcePrefix: "endpoints", 111 }) 112 if err != nil { 113 t.Fatalf("unexpected error from REST storage: %v", err) 114 } 115 if endpoints != nil && len(endpoints) > 0 { 116 ctx := genericapirequest.NewDefaultContext() 117 for ix := range endpoints { 118 key, _ := endpointsStorage.KeyFunc(ctx, endpoints[ix].Name) 119 if err := endpointsStorage.Store.Storage.Create(ctx, key, endpoints[ix], nil, 0, false); err != nil { 120 t.Fatalf("Couldn't create endpoint: %v", err) 121 } 122 } 123 } 124 125 serviceStorage, statusStorage, _, err := NewREST(restOptions, ipFamilies[0], ipAllocs, portAlloc, endpointsStorage, podStorage.Pod, nil) 126 if err != nil { 127 t.Fatalf("unexpected error from REST storage: %v", err) 128 } 129 return &wrapperRESTForTests{serviceStorage}, statusStorage, server 130 } 131 132 func makeIPAllocator(cidr *net.IPNet) ipallocator.Interface { 133 al, err := ipallocator.NewInMemory(cidr) 134 if err != nil { 135 panic(fmt.Sprintf("error creating IP allocator: %v", err)) 136 } 137 return al 138 } 139 140 func makePortAllocator(ports machineryutilnet.PortRange) portallocator.Interface { 141 al, err := portallocator.NewInMemory(ports) 142 if err != nil { 143 panic(fmt.Sprintf("error creating port allocator: %v", err)) 144 } 145 return al 146 } 147 148 // wrapperRESTForTests is a *trivial* wrapper for the real REST, which allows us to do 149 // things that are specifically to enhance test safety. 150 type wrapperRESTForTests struct { 151 *REST 152 } 153 154 func (f *wrapperRESTForTests) Create(ctx context.Context, obj runtime.Object, createValidation rest.ValidateObjectFunc, options *metav1.CreateOptions) (runtime.Object, error) { 155 // Making a DeepCopy here ensures that any in-place mutations of the input 156 // are not going to propagate to verification code, which used to happen 157 // resulting in tests that passed when they shouldn't have. 158 obj = obj.DeepCopyObject() 159 return f.REST.Create(ctx, obj, createValidation, options) 160 } 161 162 // 163 // Generic registry tests 164 // 165 166 // This is used in generic registry tests. 167 func validService() *api.Service { 168 return svctest.MakeService("foo", 169 svctest.SetClusterIPs(api.ClusterIPNone), 170 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 171 svctest.SetIPFamilies(api.IPv4Protocol)) 172 } 173 174 func TestGenericCreate(t *testing.T) { 175 storage, _, server := newStorage(t, []api.IPFamily{api.IPv4Protocol}) 176 defer server.Terminate(t) 177 defer storage.Store.DestroyFunc() 178 test := genericregistrytest.New(t, storage.Store) 179 svc := validService() 180 svc.ObjectMeta = metav1.ObjectMeta{} // because genericregistrytest 181 test.TestCreate( 182 // valid 183 svc, 184 // invalid 185 &api.Service{ 186 Spec: api.ServiceSpec{}, 187 }, 188 ) 189 } 190 191 func TestGenericUpdate(t *testing.T) { 192 clusterInternalTrafficPolicy := api.ServiceInternalTrafficPolicyCluster 193 194 storage, _, server := newStorage(t, []api.IPFamily{api.IPv4Protocol}) 195 defer server.Terminate(t) 196 defer storage.Store.DestroyFunc() 197 test := genericregistrytest.New(t, storage.Store).AllowCreateOnUpdate() 198 test.TestUpdate( 199 // valid 200 validService(), 201 // updateFunc 202 func(obj runtime.Object) runtime.Object { 203 object := obj.(*api.Service) 204 object.Spec = api.ServiceSpec{ 205 Selector: map[string]string{"bar": "baz2"}, 206 ClusterIP: api.ClusterIPNone, 207 ClusterIPs: []string{api.ClusterIPNone}, 208 SessionAffinity: api.ServiceAffinityNone, 209 Type: api.ServiceTypeClusterIP, 210 Ports: []api.ServicePort{{ 211 Port: 6502, 212 Protocol: api.ProtocolTCP, 213 TargetPort: intstr.FromInt32(6502), 214 }}, 215 InternalTrafficPolicy: &clusterInternalTrafficPolicy, 216 } 217 return object 218 }, 219 ) 220 } 221 222 func TestGenericDelete(t *testing.T) { 223 storage, _, server := newStorage(t, []api.IPFamily{api.IPv4Protocol}) 224 defer server.Terminate(t) 225 defer storage.Store.DestroyFunc() 226 test := genericregistrytest.New(t, storage.Store).AllowCreateOnUpdate().ReturnDeletedObject() 227 test.TestDelete(validService()) 228 } 229 230 func TestGenericGet(t *testing.T) { 231 storage, _, server := newStorage(t, []api.IPFamily{api.IPv4Protocol}) 232 defer server.Terminate(t) 233 defer storage.Store.DestroyFunc() 234 test := genericregistrytest.New(t, storage.Store).AllowCreateOnUpdate() 235 test.TestGet(validService()) 236 } 237 238 func TestGenericList(t *testing.T) { 239 storage, _, server := newStorage(t, []api.IPFamily{api.IPv4Protocol}) 240 defer server.Terminate(t) 241 defer storage.Store.DestroyFunc() 242 test := genericregistrytest.New(t, storage.Store).AllowCreateOnUpdate() 243 test.TestList(validService()) 244 } 245 246 func TestGenericWatch(t *testing.T) { 247 storage, _, server := newStorage(t, []api.IPFamily{api.IPv4Protocol}) 248 defer server.Terminate(t) 249 defer storage.Store.DestroyFunc() 250 test := genericregistrytest.New(t, storage.Store) 251 test.TestWatch( 252 validService(), 253 // matching labels 254 []labels.Set{}, 255 // not matching labels 256 []labels.Set{ 257 {"foo": "bar"}, 258 }, 259 // matching fields 260 []fields.Set{ 261 {"metadata.name": "foo"}, 262 }, 263 // not matching fields 264 []fields.Set{ 265 {"metadata.name": "bar"}, 266 }, 267 ) 268 } 269 270 func TestGenericShortNames(t *testing.T) { 271 storage, _, server := newStorage(t, []api.IPFamily{api.IPv4Protocol}) 272 defer server.Terminate(t) 273 defer storage.Store.DestroyFunc() 274 expected := []string{"svc"} 275 registrytest.AssertShortNames(t, storage, expected) 276 } 277 278 func TestGenericCategories(t *testing.T) { 279 storage, _, server := newStorage(t, []api.IPFamily{api.IPv4Protocol}) 280 defer server.Terminate(t) 281 defer storage.Store.DestroyFunc() 282 expected := []string{"all"} 283 registrytest.AssertCategories(t, storage, expected) 284 } 285 286 // 287 // Tests of internal functions 288 // 289 290 func TestNormalizeClusterIPs(t *testing.T) { 291 makeServiceWithClusterIp := func(clusterIP string, clusterIPs []string) *api.Service { 292 return &api.Service{ 293 Spec: api.ServiceSpec{ 294 ClusterIP: clusterIP, 295 ClusterIPs: clusterIPs, 296 }, 297 } 298 } 299 300 testCases := []struct { 301 name string 302 oldService *api.Service 303 newService *api.Service 304 expectedClusterIP string 305 expectedClusterIPs []string 306 }{{ 307 name: "new - only clusterip used", 308 oldService: nil, 309 newService: makeServiceWithClusterIp("10.0.0.10", nil), 310 expectedClusterIP: "10.0.0.10", 311 expectedClusterIPs: []string{"10.0.0.10"}, 312 }, { 313 name: "new - only clusterips used", 314 oldService: nil, 315 newService: makeServiceWithClusterIp("", []string{"10.0.0.10"}), 316 expectedClusterIP: "", // this is a validation issue, and validation will catch it 317 expectedClusterIPs: []string{"10.0.0.10"}, 318 }, { 319 name: "new - both used", 320 oldService: nil, 321 newService: makeServiceWithClusterIp("10.0.0.10", []string{"10.0.0.10"}), 322 expectedClusterIP: "10.0.0.10", 323 expectedClusterIPs: []string{"10.0.0.10"}, 324 }, { 325 name: "update - no change", 326 oldService: makeServiceWithClusterIp("10.0.0.10", []string{"10.0.0.10"}), 327 newService: makeServiceWithClusterIp("10.0.0.10", []string{"10.0.0.10"}), 328 expectedClusterIP: "10.0.0.10", 329 expectedClusterIPs: []string{"10.0.0.10"}, 330 }, { 331 name: "update - malformed change", 332 oldService: makeServiceWithClusterIp("10.0.0.10", []string{"10.0.0.10"}), 333 newService: makeServiceWithClusterIp("10.0.0.11", []string{"10.0.0.11"}), 334 expectedClusterIP: "10.0.0.11", 335 expectedClusterIPs: []string{"10.0.0.11"}, 336 }, { 337 name: "update - malformed change on secondary ip", 338 oldService: makeServiceWithClusterIp("10.0.0.10", []string{"10.0.0.10", "2000::1"}), 339 newService: makeServiceWithClusterIp("10.0.0.11", []string{"10.0.0.11", "3000::1"}), 340 expectedClusterIP: "10.0.0.11", 341 expectedClusterIPs: []string{"10.0.0.11", "3000::1"}, 342 }, { 343 name: "update - upgrade", 344 oldService: makeServiceWithClusterIp("10.0.0.10", []string{"10.0.0.10"}), 345 newService: makeServiceWithClusterIp("10.0.0.10", []string{"10.0.0.10", "2000::1"}), 346 expectedClusterIP: "10.0.0.10", 347 expectedClusterIPs: []string{"10.0.0.10", "2000::1"}, 348 }, { 349 name: "update - downgrade", 350 oldService: makeServiceWithClusterIp("10.0.0.10", []string{"10.0.0.10", "2000::1"}), 351 newService: makeServiceWithClusterIp("10.0.0.10", []string{"10.0.0.10"}), 352 expectedClusterIP: "10.0.0.10", 353 expectedClusterIPs: []string{"10.0.0.10"}, 354 }, { 355 name: "update - user cleared cluster IP", 356 oldService: makeServiceWithClusterIp("10.0.0.10", []string{"10.0.0.10"}), 357 newService: makeServiceWithClusterIp("", []string{"10.0.0.10"}), 358 expectedClusterIP: "", 359 expectedClusterIPs: nil, 360 }, { 361 name: "update - user cleared clusterIPs", // *MUST* REMAIN FOR OLD CLIENTS 362 oldService: makeServiceWithClusterIp("10.0.0.10", []string{"10.0.0.10"}), 363 newService: makeServiceWithClusterIp("10.0.0.10", nil), 364 expectedClusterIP: "10.0.0.10", 365 expectedClusterIPs: []string{"10.0.0.10"}, 366 }, { 367 name: "update - user cleared both", 368 oldService: makeServiceWithClusterIp("10.0.0.10", []string{"10.0.0.10"}), 369 newService: makeServiceWithClusterIp("", nil), 370 expectedClusterIP: "", 371 expectedClusterIPs: nil, 372 }, { 373 name: "update - user cleared ClusterIP but changed clusterIPs", 374 oldService: makeServiceWithClusterIp("10.0.0.10", []string{"10.0.0.10"}), 375 newService: makeServiceWithClusterIp("", []string{"10.0.0.11"}), 376 expectedClusterIP: "", /* validation catches this */ 377 expectedClusterIPs: []string{"10.0.0.11"}, 378 }, { 379 name: "update - user cleared ClusterIPs but changed ClusterIP", 380 oldService: makeServiceWithClusterIp("10.0.0.10", []string{"10.0.0.10", "2000::1"}), 381 newService: makeServiceWithClusterIp("10.0.0.11", nil), 382 expectedClusterIP: "10.0.0.11", 383 expectedClusterIPs: nil, 384 }, { 385 name: "update - user changed from None to ClusterIP", 386 oldService: makeServiceWithClusterIp("None", []string{"None"}), 387 newService: makeServiceWithClusterIp("10.0.0.10", []string{"None"}), 388 expectedClusterIP: "10.0.0.10", 389 expectedClusterIPs: []string{"10.0.0.10"}, 390 }, { 391 name: "update - user changed from ClusterIP to None", 392 oldService: makeServiceWithClusterIp("10.0.0.10", []string{"10.0.0.10"}), 393 newService: makeServiceWithClusterIp("None", []string{"10.0.0.10"}), 394 expectedClusterIP: "None", 395 expectedClusterIPs: []string{"None"}, 396 }, { 397 name: "update - user changed from ClusterIP to None and changed ClusterIPs in a dual stack (new client making a mistake)", 398 oldService: makeServiceWithClusterIp("10.0.0.10", []string{"10.0.0.10", "2000::1"}), 399 newService: makeServiceWithClusterIp("None", []string{"10.0.0.11", "2000::1"}), 400 expectedClusterIP: "None", 401 expectedClusterIPs: []string{"10.0.0.11", "2000::1"}, 402 }} 403 404 for _, tc := range testCases { 405 t.Run(tc.name, func(t *testing.T) { 406 normalizeClusterIPs(After{tc.newService}, Before{tc.oldService}) 407 408 if tc.newService == nil { 409 t.Fatalf("unexpected new service to be nil") 410 } 411 412 if tc.newService.Spec.ClusterIP != tc.expectedClusterIP { 413 t.Fatalf("expected clusterIP [%v] got [%v]", tc.expectedClusterIP, tc.newService.Spec.ClusterIP) 414 } 415 416 if len(tc.newService.Spec.ClusterIPs) != len(tc.expectedClusterIPs) { 417 t.Fatalf("expected clusterIPs %v got %v", tc.expectedClusterIPs, tc.newService.Spec.ClusterIPs) 418 } 419 420 for idx, clusterIP := range tc.newService.Spec.ClusterIPs { 421 if clusterIP != tc.expectedClusterIPs[idx] { 422 t.Fatalf("expected clusterIP [%v] at index[%v] got [%v]", tc.expectedClusterIPs[idx], idx, tc.newService.Spec.ClusterIPs[idx]) 423 424 } 425 } 426 }) 427 } 428 } 429 430 func TestPatchAllocatedValues(t *testing.T) { 431 testCases := []struct { 432 name string 433 before *api.Service 434 update *api.Service 435 expectSameClusterIPs bool 436 expectReducedClusterIPs bool 437 expectSameNodePort bool 438 expectSameHCNP bool 439 }{{ 440 name: "all_patched", 441 before: svctest.MakeService("foo", 442 svctest.SetTypeLoadBalancer, 443 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal), 444 svctest.SetClusterIPs("10.0.0.93", "2000::76"), 445 svctest.SetUniqueNodePorts, 446 svctest.SetHealthCheckNodePort(31234)), 447 update: svctest.MakeService("foo", 448 svctest.SetTypeLoadBalancer, 449 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal)), 450 expectSameClusterIPs: true, 451 expectSameNodePort: true, 452 expectSameHCNP: true, 453 }, { 454 name: "IPs_patched", 455 before: svctest.MakeService("foo", 456 svctest.SetTypeClusterIP, 457 svctest.SetClusterIPs("10.0.0.93", "2000::76"), 458 // these are not valid, but prove the test 459 svctest.SetUniqueNodePorts, 460 svctest.SetHealthCheckNodePort(31234)), 461 update: svctest.MakeService("foo", 462 svctest.SetTypeClusterIP), 463 expectSameClusterIPs: true, 464 }, { 465 name: "NPs_patched", 466 before: svctest.MakeService("foo", 467 svctest.SetTypeNodePort, 468 svctest.SetClusterIPs("10.0.0.93", "2000::76"), 469 svctest.SetUniqueNodePorts, 470 // this is not valid, but proves the test 471 svctest.SetHealthCheckNodePort(31234)), 472 update: svctest.MakeService("foo", 473 svctest.SetTypeNodePort, 474 svctest.SetClusterIPs("10.0.0.93", "2000::76")), 475 expectSameClusterIPs: true, 476 expectSameNodePort: true, 477 }, { 478 name: "HCNP_patched", 479 before: svctest.MakeService("foo", 480 svctest.SetTypeLoadBalancer, 481 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal), 482 svctest.SetClusterIPs("10.0.0.93", "2000::76"), 483 svctest.SetUniqueNodePorts, 484 svctest.SetHealthCheckNodePort(31234)), 485 update: svctest.MakeService("foo", 486 svctest.SetTypeLoadBalancer, 487 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal), 488 svctest.SetClusterIPs("10.0.0.93", "2000::76"), 489 svctest.SetUniqueNodePorts), 490 expectSameClusterIPs: true, 491 expectSameNodePort: true, 492 expectSameHCNP: true, 493 }, { 494 name: "nothing_patched", 495 before: svctest.MakeService("foo", 496 svctest.SetTypeExternalName, 497 // these are not valid, but prove the test 498 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal), 499 svctest.SetClusterIPs("10.0.0.93", "2000::76"), 500 svctest.SetUniqueNodePorts, 501 svctest.SetHealthCheckNodePort(31234)), 502 update: svctest.MakeService("foo", 503 svctest.SetTypeExternalName, 504 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal)), 505 }, { 506 name: "reset_NodePort", 507 before: svctest.MakeService("foo", 508 svctest.SetTypeLoadBalancer, 509 svctest.SetAllocateLoadBalancerNodePorts(false), 510 svctest.SetClusterIPs("10.0.0.93", "2000::76"), 511 svctest.SetUniqueNodePorts, 512 svctest.SetHealthCheckNodePort(31234)), 513 update: svctest.MakeService("foo", 514 svctest.SetTypeLoadBalancer, 515 svctest.SetAllocateLoadBalancerNodePorts(false), 516 svctest.SetClusterIPs("10.0.0.93", "2000::76"), 517 svctest.SetNodePorts(0)), 518 expectSameClusterIPs: true, 519 expectSameNodePort: false, 520 }, { 521 name: "reset_partial_NodePorts", 522 before: svctest.MakeService("foo", 523 svctest.SetTypeLoadBalancer, 524 svctest.SetAllocateLoadBalancerNodePorts(false), 525 svctest.SetClusterIPs("10.0.0.93", "2000::76"), 526 svctest.SetPorts( 527 svctest.MakeServicePort("", 93, intstr.FromInt32(76), api.ProtocolTCP), 528 svctest.MakeServicePort("", 94, intstr.FromInt32(76), api.ProtocolTCP), 529 ), 530 svctest.SetUniqueNodePorts, 531 svctest.SetHealthCheckNodePort(31234)), 532 update: svctest.MakeService("foo", 533 svctest.SetTypeLoadBalancer, 534 svctest.SetAllocateLoadBalancerNodePorts(false), 535 svctest.SetClusterIPs("10.0.0.93", "2000::76"), 536 svctest.SetPorts( 537 svctest.MakeServicePort("", 93, intstr.FromInt32(76), api.ProtocolTCP), 538 svctest.MakeServicePort("", 94, intstr.FromInt32(76), api.ProtocolTCP), 539 ), 540 svctest.SetUniqueNodePorts, 541 func(service *api.Service) { 542 service.Spec.Ports[1].NodePort = 0 543 }), 544 expectSameClusterIPs: true, 545 expectSameNodePort: false, 546 }, { 547 name: "keep_NodePort", 548 before: svctest.MakeService("foo", 549 svctest.SetTypeLoadBalancer, 550 svctest.SetAllocateLoadBalancerNodePorts(true), 551 svctest.SetClusterIPs("10.0.0.93", "2000::76"), 552 svctest.SetUniqueNodePorts, 553 svctest.SetHealthCheckNodePort(31234)), 554 update: svctest.MakeService("foo", 555 svctest.SetTypeLoadBalancer, 556 svctest.SetAllocateLoadBalancerNodePorts(true), 557 svctest.SetClusterIPs("10.0.0.93", "2000::76"), 558 svctest.SetNodePorts(0)), 559 expectSameClusterIPs: true, 560 expectSameNodePort: true, 561 }} 562 563 for _, tc := range testCases { 564 t.Run(tc.name, func(t *testing.T) { 565 update := tc.update.DeepCopy() 566 patchAllocatedValues(After{update}, Before{tc.before}) 567 568 beforeIP := tc.before.Spec.ClusterIP 569 updateIP := update.Spec.ClusterIP 570 if tc.expectSameClusterIPs || tc.expectReducedClusterIPs { 571 if beforeIP != updateIP { 572 t.Errorf("expected clusterIP to be patched: %q != %q", beforeIP, updateIP) 573 } 574 } else if beforeIP == updateIP { 575 t.Errorf("expected clusterIP to not be patched: %q == %q", beforeIP, updateIP) 576 } 577 578 beforeIPs := tc.before.Spec.ClusterIPs 579 updateIPs := update.Spec.ClusterIPs 580 if tc.expectSameClusterIPs { 581 if !cmp.Equal(beforeIPs, updateIPs) { 582 t.Errorf("expected clusterIPs to be patched: %q != %q", beforeIPs, updateIPs) 583 } 584 } else if tc.expectReducedClusterIPs { 585 if len(updateIPs) != 1 || beforeIPs[0] != updateIPs[0] { 586 t.Errorf("expected clusterIPs to be trim-patched: %q -> %q", beforeIPs, updateIPs) 587 } 588 } else if cmp.Equal(beforeIPs, updateIPs) { 589 t.Errorf("expected clusterIPs to not be patched: %q == %q", beforeIPs, updateIPs) 590 } 591 592 bNodePorts, uNodePorts := make([]int32, 0), make([]int32, 0) 593 for _, item := range tc.before.Spec.Ports { 594 bNodePorts = append(bNodePorts, item.NodePort) 595 } 596 for _, item := range update.Spec.Ports { 597 uNodePorts = append(uNodePorts, item.NodePort) 598 } 599 if tc.expectSameNodePort && !reflect.DeepEqual(bNodePorts, uNodePorts) { 600 t.Errorf("expected nodePort to be patched: %v != %v", bNodePorts, uNodePorts) 601 } else if !tc.expectSameNodePort && reflect.DeepEqual(bNodePorts, uNodePorts) { 602 t.Errorf("expected nodePort to not be patched: %v == %v", bNodePorts, uNodePorts) 603 } 604 605 if b, u := tc.before.Spec.HealthCheckNodePort, update.Spec.HealthCheckNodePort; tc.expectSameHCNP && b != u { 606 t.Errorf("expected healthCheckNodePort to be patched: %d != %d", b, u) 607 } else if !tc.expectSameHCNP && b == u { 608 t.Errorf("expected healthCheckNodePort to not be patched: %d == %d", b, u) 609 } 610 }) 611 } 612 } 613 614 func TestServiceDefaultOnRead(t *testing.T) { 615 // Helper makes a mostly-valid ServiceList. Test-cases can tweak it as needed. 616 makeServiceList := func(tweaks ...svctest.Tweak) *api.ServiceList { 617 svc := svctest.MakeService("foo", tweaks...) 618 list := &api.ServiceList{ 619 Items: []api.Service{*svc}, 620 } 621 return list 622 } 623 624 testCases := []struct { 625 name string 626 input runtime.Object 627 expect runtime.Object 628 }{{ 629 name: "single v4", 630 input: svctest.MakeService("foo", svctest.SetClusterIPs("10.0.0.1")), 631 expect: svctest.MakeService("foo", svctest.SetClusterIPs("10.0.0.1"), 632 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 633 svctest.SetIPFamilies(api.IPv4Protocol)), 634 }, { 635 name: "single v6", 636 input: svctest.MakeService("foo", svctest.SetClusterIPs("2000::1")), 637 expect: svctest.MakeService("foo", svctest.SetClusterIPs("2000::1"), 638 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 639 svctest.SetIPFamilies(api.IPv6Protocol)), 640 }, { 641 name: "missing clusterIPs v4", 642 input: svctest.MakeService("foo", svctest.SetClusterIP("10.0.0.1")), 643 expect: svctest.MakeService("foo", svctest.SetClusterIPs("10.0.0.1"), 644 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 645 svctest.SetIPFamilies(api.IPv4Protocol)), 646 }, { 647 name: "missing clusterIPs v6", 648 input: svctest.MakeService("foo", svctest.SetClusterIP("2000::1")), 649 expect: svctest.MakeService("foo", svctest.SetClusterIPs("2000::1"), 650 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 651 svctest.SetIPFamilies(api.IPv6Protocol)), 652 }, { 653 name: "list v4", 654 input: makeServiceList(svctest.SetClusterIPs("10.0.0.1")), 655 expect: makeServiceList(svctest.SetClusterIPs("10.0.0.1"), 656 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 657 svctest.SetIPFamilies(api.IPv4Protocol)), 658 }, { 659 name: "list missing clusterIPs v4", 660 input: makeServiceList(svctest.SetClusterIP("10.0.0.1")), 661 expect: makeServiceList(svctest.SetClusterIPs("10.0.0.1"), 662 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 663 svctest.SetIPFamilies(api.IPv4Protocol)), 664 }, { 665 name: "external name", 666 input: makeServiceList(svctest.SetTypeExternalName, svctest.SetInternalTrafficPolicy(api.ServiceInternalTrafficPolicyCluster)), 667 expect: makeServiceList(svctest.SetTypeExternalName), 668 }, { 669 name: "dual v4v6", 670 input: svctest.MakeService("foo", svctest.SetClusterIPs("10.0.0.1", "2000::1")), 671 expect: svctest.MakeService("foo", svctest.SetClusterIPs("10.0.0.1", "2000::1"), 672 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 673 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 674 }, { 675 name: "dual v6v4", 676 input: svctest.MakeService("foo", svctest.SetClusterIPs("2000::1", "10.0.0.1")), 677 expect: svctest.MakeService("foo", svctest.SetClusterIPs("2000::1", "10.0.0.1"), 678 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 679 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 680 }, { 681 name: "headless", 682 input: svctest.MakeService("foo", svctest.SetHeadless), 683 expect: svctest.MakeService("foo", svctest.SetHeadless, 684 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 685 svctest.SetIPFamilies(api.IPv4Protocol)), 686 }, { 687 name: "headless selectorless", 688 input: svctest.MakeService("foo", svctest.SetHeadless, 689 svctest.SetSelector(map[string]string{})), 690 expect: svctest.MakeService("foo", svctest.SetHeadless, 691 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 692 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 693 }, { 694 name: "headless selectorless pre-set", 695 input: svctest.MakeService("foo", svctest.SetHeadless, 696 svctest.SetSelector(map[string]string{}), 697 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 698 svctest.SetIPFamilies(api.IPv6Protocol)), 699 expect: svctest.MakeService("foo", svctest.SetHeadless, 700 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 701 svctest.SetIPFamilies(api.IPv6Protocol)), 702 }, { 703 name: "not Service or ServiceList", 704 input: &api.Pod{}, 705 }} 706 707 for _, tc := range testCases { 708 t.Run(tc.name, func(t *testing.T) { 709 storage, _, server := newStorage(t, []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}) 710 defer server.Terminate(t) 711 defer storage.Store.DestroyFunc() 712 713 tmp := tc.input.DeepCopyObject() 714 storage.defaultOnRead(tmp) 715 716 svc, ok := tmp.(*api.Service) 717 if !ok { 718 list, ok := tmp.(*api.ServiceList) 719 if !ok { 720 return 721 } 722 svc = &list.Items[0] 723 } 724 725 exp, ok := tc.expect.(*api.Service) 726 if !ok { 727 list, ok := tc.expect.(*api.ServiceList) 728 if !ok { 729 return 730 } 731 exp = &list.Items[0] 732 } 733 734 // Verify fields we know are affected 735 if want, got := exp.Spec.ClusterIP, svc.Spec.ClusterIP; want != got { 736 t.Errorf("clusterIP: expected %v, got %v", want, got) 737 } 738 if want, got := exp.Spec.ClusterIPs, svc.Spec.ClusterIPs; !reflect.DeepEqual(want, got) { 739 t.Errorf("clusterIPs: expected %v, got %v", want, got) 740 } 741 if want, got := fmtIPFamilyPolicy(exp.Spec.IPFamilyPolicy), fmtIPFamilyPolicy(svc.Spec.IPFamilyPolicy); want != got { 742 t.Errorf("ipFamilyPolicy: expected %v, got %v", want, got) 743 } 744 if want, got := exp.Spec.IPFamilies, svc.Spec.IPFamilies; !reflect.DeepEqual(want, got) { 745 t.Errorf("ipFamilies: expected %v, got %v", want, got) 746 } 747 if want, got := fmtInternalTrafficPolicy(exp.Spec.InternalTrafficPolicy), fmtInternalTrafficPolicy(svc.Spec.InternalTrafficPolicy); want != got { 748 t.Errorf("internalTrafficPolicy: expected %v, got %v", want, got) 749 } 750 }) 751 } 752 } 753 754 // 755 // Scaffolding for create-update-delete tests. Many tests can and should be 756 // written in terms of this. 757 // 758 759 type cudTestCase struct { 760 name string 761 line string // if not empty, will be logged with errors, use line() to set 762 create svcTestCase 763 beforeUpdate func(t *testing.T, storage *wrapperRESTForTests) 764 update svcTestCase 765 } 766 767 type svcTestCase struct { 768 svc *api.Service 769 expectError bool 770 771 // We could calculate these by looking at the Service, but that's a 772 // vector for test bugs and more importantly it makes the test cases less 773 // self-documenting. 774 expectClusterIPs bool 775 expectStackDowngrade bool 776 expectHeadless bool 777 expectNodePorts bool 778 expectHealthCheckNodePort bool 779 780 // Additional proofs, provided by the tests which use this. 781 prove []svcTestProof 782 } 783 784 type svcTestProof func(t *testing.T, storage *wrapperRESTForTests, before, after *api.Service) 785 786 // Most tests will call this. 787 func helpTestCreateUpdateDelete(t *testing.T, testCases []cudTestCase) { 788 t.Helper() 789 helpTestCreateUpdateDeleteWithFamilies(t, testCases, []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}) 790 } 791 792 func helpTestCreateUpdateDeleteWithFamilies(t *testing.T, testCases []cudTestCase, ipFamilies []api.IPFamily) { 793 // NOTE: do not call t.Helper() here. It's more useful for errors to be 794 // attributed to lines in this function than the caller of it. 795 796 storage, _, server := newStorage(t, ipFamilies) 797 defer server.Terminate(t) 798 defer storage.Store.DestroyFunc() 799 800 for _, tc := range testCases { 801 name := tc.name 802 if tc.line != "" { 803 name += "__@L" + tc.line 804 } 805 t.Run(name, func(t *testing.T) { 806 ctx := genericapirequest.NewDefaultContext() 807 808 // Create the object as specified and check the results. 809 obj, err := storage.Create(ctx, tc.create.svc, rest.ValidateAllObjectFunc, &metav1.CreateOptions{}) 810 if tc.create.expectError && err != nil { 811 return 812 } 813 if err != nil { 814 t.Fatalf("unexpected error creating service: %v", err) 815 } 816 defer storage.Delete(ctx, tc.create.svc.Name, rest.ValidateAllObjectFunc, &metav1.DeleteOptions{}) // in case 817 if tc.create.expectError && err == nil { 818 t.Fatalf("unexpected success creating service") 819 } 820 createdSvc := obj.(*api.Service) 821 if !verifyEquiv(t, "create", &tc.create, createdSvc) { 822 return 823 } 824 verifyExpectations(t, storage, tc.create, tc.create.svc, createdSvc) 825 lastSvc := createdSvc 826 827 // The update phase is optional. 828 if tc.update.svc != nil { 829 // Allow callers to do something between create and update. 830 if tc.beforeUpdate != nil { 831 tc.beforeUpdate(t, storage) 832 } 833 834 // Update the object to the new state and check the results. 835 obj, created, err := storage.Update(ctx, tc.update.svc.Name, 836 rest.DefaultUpdatedObjectInfo(tc.update.svc), rest.ValidateAllObjectFunc, 837 rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{}) 838 if tc.update.expectError && err != nil { 839 return 840 } 841 if err != nil { 842 t.Fatalf("unexpected error updating service: %v", err) 843 } 844 if tc.update.expectError && err == nil { 845 t.Fatalf("unexpected success updating service") 846 } 847 if created { 848 t.Fatalf("unexpected create-on-update") 849 } 850 updatedSvc := obj.(*api.Service) 851 if !verifyEquiv(t, "update", &tc.update, updatedSvc) { 852 return 853 } 854 verifyExpectations(t, storage, tc.update, createdSvc, updatedSvc) 855 lastSvc = updatedSvc 856 } 857 858 // Delete the object and check the results. 859 _, _, err = storage.Delete(ctx, tc.create.svc.Name, rest.ValidateAllObjectFunc, &metav1.DeleteOptions{}) 860 if err != nil { 861 t.Fatalf("unexpected error deleting service: %v", err) 862 } 863 verifyExpectations(t, storage, svcTestCase{ /* all false */ }, lastSvc, nil) 864 }) 865 } 866 } 867 868 // line returns the line number of the caller, if possible. This is useful in 869 // tests with a large number of cases - when something goes wrong you can find 870 // which case more easily. 871 func line() string { 872 _, _, line, ok := stdruntime.Caller(1) 873 var s string 874 if ok { 875 s = fmt.Sprintf("%d", line) 876 } else { 877 s = "<??>" 878 } 879 return s 880 } 881 882 // This makes the test-helpers testable. 883 type testingTInterface interface { 884 Helper() 885 Errorf(format string, args ...interface{}) 886 } 887 888 type fakeTestingT struct { 889 t *testing.T 890 } 891 892 func (f fakeTestingT) Helper() {} 893 894 func (f fakeTestingT) Errorf(format string, args ...interface{}) {} 895 896 func verifyEquiv(t testingTInterface, call string, tc *svcTestCase, got *api.Service) bool { 897 t.Helper() 898 899 // For when we compare objects. 900 options := []cmp.Option{ 901 // These are system-assigned values, we don't need to compare them. 902 cmpopts.IgnoreFields(api.Service{}, "UID", "ResourceVersion", "CreationTimestamp"), 903 // Treat nil slices and empty slices as the same (e.g. clusterIPs). 904 cmpopts.EquateEmpty(), 905 } 906 907 // For allocated fields, we want to be able to compare cleanly whether the 908 // input specified values or not. 909 want := tc.svc.DeepCopy() 910 if tc.expectClusterIPs || tc.expectHeadless { 911 if want.Spec.ClusterIP == "" { 912 want.Spec.ClusterIP = got.Spec.ClusterIP 913 } 914 if want.Spec.IPFamilyPolicy == nil { 915 want.Spec.IPFamilyPolicy = got.Spec.IPFamilyPolicy 916 } 917 if tc.expectStackDowngrade && len(want.Spec.ClusterIPs) > len(got.Spec.ClusterIPs) { 918 want.Spec.ClusterIPs = want.Spec.ClusterIPs[0:1] 919 } else if len(got.Spec.ClusterIPs) > len(want.Spec.ClusterIPs) { 920 want.Spec.ClusterIPs = append(want.Spec.ClusterIPs, got.Spec.ClusterIPs[len(want.Spec.ClusterIPs):]...) 921 } 922 if tc.expectStackDowngrade && len(want.Spec.IPFamilies) > len(got.Spec.ClusterIPs) { 923 want.Spec.IPFamilies = want.Spec.IPFamilies[0:1] 924 } else if len(got.Spec.IPFamilies) > len(want.Spec.IPFamilies) { 925 want.Spec.IPFamilies = append(want.Spec.IPFamilies, got.Spec.IPFamilies[len(want.Spec.IPFamilies):]...) 926 } 927 } 928 929 if tc.expectNodePorts { 930 for i := range want.Spec.Ports { 931 p := &want.Spec.Ports[i] 932 if p.NodePort == 0 { 933 p.NodePort = got.Spec.Ports[i].NodePort 934 } 935 } 936 } 937 if tc.expectHealthCheckNodePort { 938 if want.Spec.HealthCheckNodePort == 0 { 939 want.Spec.HealthCheckNodePort = got.Spec.HealthCheckNodePort 940 } 941 } 942 943 if !cmp.Equal(want, got, options...) { 944 t.Errorf("unexpected result from %s:\n%s", call, cmp.Diff(want, got, options...)) 945 return false 946 } 947 return true 948 } 949 950 // Quis custodiet ipsos custodes? 951 func TestVerifyEquiv(t *testing.T) { 952 testCases := []struct { 953 name string 954 input svcTestCase 955 output *api.Service 956 expect bool 957 }{{ 958 name: "ExternalName", 959 input: svcTestCase{ 960 svc: svctest.MakeService("foo", svctest.SetTypeExternalName), 961 }, 962 output: svctest.MakeService("foo", svctest.SetTypeExternalName), 963 expect: true, 964 }, { 965 name: "ClusterIPs_unspecified", 966 input: svcTestCase{ 967 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP), 968 expectClusterIPs: true, 969 }, 970 output: svctest.MakeService("foo", svctest.SetTypeClusterIP, svctest.SetClusterIPs("10.0.0.1", "2000:1")), 971 expect: true, 972 }, { 973 name: "ClusterIPs_specified", 974 input: svcTestCase{ 975 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, svctest.SetClusterIPs("10.0.0.1", "2000:1")), 976 expectClusterIPs: true, 977 }, 978 output: svctest.MakeService("foo", svctest.SetTypeClusterIP, svctest.SetClusterIPs("10.0.0.1", "2000:1")), 979 expect: true, 980 }, { 981 name: "ClusterIPs_wrong", 982 input: svcTestCase{ 983 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, svctest.SetClusterIPs("10.0.0.0", "2000:0")), 984 expectClusterIPs: true, 985 }, 986 output: svctest.MakeService("foo", svctest.SetTypeClusterIP, svctest.SetClusterIPs("10.0.0.1", "2000:1")), 987 expect: false, 988 }, { 989 name: "ClusterIPs_partial", 990 input: svcTestCase{ 991 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, svctest.SetClusterIPs("10.0.0.1")), 992 expectClusterIPs: true, 993 }, 994 output: svctest.MakeService("foo", svctest.SetTypeClusterIP, svctest.SetClusterIPs("10.0.0.1", "2000:1")), 995 expect: true, 996 }, { 997 name: "NodePort_unspecified", 998 input: svcTestCase{ 999 svc: svctest.MakeService("foo", svctest.SetTypeNodePort), 1000 expectClusterIPs: true, 1001 expectNodePorts: true, 1002 }, 1003 output: svctest.MakeService("foo", svctest.SetTypeNodePort, svctest.SetUniqueNodePorts), 1004 expect: true, 1005 }, { 1006 name: "NodePort_specified", 1007 input: svcTestCase{ 1008 svc: svctest.MakeService("foo", svctest.SetTypeNodePort, svctest.SetNodePorts(93)), 1009 expectClusterIPs: true, 1010 expectNodePorts: true, 1011 }, 1012 output: svctest.MakeService("foo", svctest.SetTypeNodePort, svctest.SetNodePorts(93)), 1013 expect: true, 1014 }, { 1015 name: "NodePort_wrong", 1016 input: svcTestCase{ 1017 svc: svctest.MakeService("foo", svctest.SetTypeNodePort, svctest.SetNodePorts(93)), 1018 expectClusterIPs: true, 1019 expectNodePorts: true, 1020 }, 1021 output: svctest.MakeService("foo", svctest.SetTypeNodePort, svctest.SetNodePorts(76)), 1022 expect: false, 1023 }, { 1024 name: "NodePort_partial", 1025 input: svcTestCase{ 1026 svc: svctest.MakeService("foo", svctest.SetTypeNodePort, 1027 svctest.SetPorts( 1028 svctest.MakeServicePort("p", 80, intstr.FromInt32(80), api.ProtocolTCP), 1029 svctest.MakeServicePort("q", 443, intstr.FromInt32(443), api.ProtocolTCP)), 1030 svctest.SetNodePorts(93)), 1031 expectClusterIPs: true, 1032 expectNodePorts: true, 1033 }, 1034 output: svctest.MakeService("foo", svctest.SetTypeNodePort, 1035 svctest.SetPorts( 1036 svctest.MakeServicePort("p", 80, intstr.FromInt32(80), api.ProtocolTCP), 1037 svctest.MakeServicePort("q", 443, intstr.FromInt32(443), api.ProtocolTCP)), 1038 svctest.SetNodePorts(93, 76)), 1039 expect: true, 1040 }, { 1041 name: "HealthCheckNodePort_unspecified", 1042 input: svcTestCase{ 1043 svc: svctest.MakeService("foo", svctest.SetTypeLoadBalancer, 1044 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal)), 1045 expectClusterIPs: true, 1046 expectNodePorts: true, 1047 expectHealthCheckNodePort: true, 1048 }, 1049 output: svctest.MakeService("foo", svctest.SetTypeLoadBalancer, 1050 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal), 1051 svctest.SetHealthCheckNodePort(93)), 1052 expect: true, 1053 }, { 1054 name: "HealthCheckNodePort_specified", 1055 input: svcTestCase{ 1056 svc: svctest.MakeService("foo", svctest.SetTypeLoadBalancer, 1057 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal), 1058 svctest.SetHealthCheckNodePort(93)), 1059 expectClusterIPs: true, 1060 expectNodePorts: true, 1061 expectHealthCheckNodePort: true, 1062 }, 1063 output: svctest.MakeService("foo", svctest.SetTypeLoadBalancer, 1064 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal), 1065 svctest.SetHealthCheckNodePort(93)), 1066 expect: true, 1067 }, { 1068 name: "HealthCheckNodePort_wrong", 1069 input: svcTestCase{ 1070 svc: svctest.MakeService("foo", svctest.SetTypeLoadBalancer, 1071 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal), 1072 svctest.SetHealthCheckNodePort(93)), 1073 expectClusterIPs: true, 1074 expectNodePorts: true, 1075 expectHealthCheckNodePort: true, 1076 }, 1077 output: svctest.MakeService("foo", svctest.SetTypeLoadBalancer, 1078 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal), 1079 svctest.SetHealthCheckNodePort(76)), 1080 expect: false, 1081 }} 1082 1083 for _, tc := range testCases { 1084 t.Run(tc.name, func(t *testing.T) { 1085 result := verifyEquiv(fakeTestingT{t}, "test", &tc.input, tc.output) 1086 if result != tc.expect { 1087 t.Errorf("expected %v, got %v", tc.expect, result) 1088 } 1089 }) 1090 } 1091 } 1092 1093 func verifyExpectations(t *testing.T, storage *wrapperRESTForTests, tc svcTestCase, before, after *api.Service) { 1094 t.Helper() 1095 1096 if tc.expectClusterIPs { 1097 proveClusterIPsAllocated(t, storage, before, after) 1098 } else if tc.expectHeadless { 1099 proveHeadless(t, storage, before, after) 1100 } else { 1101 proveClusterIPsDeallocated(t, storage, before, after) 1102 } 1103 if tc.expectNodePorts { 1104 proveNodePortsAllocated(t, storage, before, after) 1105 } else { 1106 proveNodePortsDeallocated(t, storage, before, after) 1107 } 1108 if tc.expectHealthCheckNodePort { 1109 proveHealthCheckNodePortAllocated(t, storage, before, after) 1110 } else { 1111 proveHealthCheckNodePortDeallocated(t, storage, before, after) 1112 } 1113 1114 for _, p := range tc.prove { 1115 p(t, storage, before, after) 1116 } 1117 } 1118 1119 func callName(before, after *api.Service) string { 1120 if before == nil && after != nil { 1121 return "create" 1122 } 1123 if before != nil && after != nil { 1124 return "update" 1125 } 1126 if before != nil && after == nil { 1127 return "delete" 1128 } 1129 panic("this test is broken: before and after are both nil") 1130 } 1131 1132 func ipIsAllocated(t *testing.T, alloc ipallocator.Interface, ipstr string) bool { 1133 t.Helper() 1134 ip := netutils.ParseIPSloppy(ipstr) 1135 if ip == nil { 1136 t.Errorf("error parsing IP %q", ipstr) 1137 return false 1138 } 1139 return alloc.Has(ip) 1140 } 1141 1142 func portIsAllocated(t *testing.T, alloc portallocator.Interface, port int32) bool { 1143 t.Helper() 1144 if port == 0 { 1145 t.Errorf("port is 0") 1146 return false 1147 } 1148 return alloc.Has(int(port)) 1149 } 1150 1151 func proveClusterIPsAllocated(t *testing.T, storage *wrapperRESTForTests, before, after *api.Service) { 1152 t.Helper() 1153 1154 if sing, plur := after.Spec.ClusterIP, after.Spec.ClusterIPs[0]; sing != plur { 1155 t.Errorf("%s: expected clusterIP == clusterIPs[0]: %q != %q", callName(before, after), sing, plur) 1156 } 1157 1158 for _, clip := range after.Spec.ClusterIPs { 1159 if !ipIsAllocated(t, storage.alloc.serviceIPAllocatorsByFamily[familyOf(clip)], clip) { 1160 t.Errorf("%s: expected clusterIP to be allocated: %q", callName(before, after), clip) 1161 } 1162 } 1163 1164 if lc, lf := len(after.Spec.ClusterIPs), len(after.Spec.IPFamilies); lc != lf { 1165 t.Errorf("%s: expected same number of clusterIPs and ipFamilies: %d != %d", callName(before, after), lc, lf) 1166 } 1167 1168 for i, fam := range after.Spec.IPFamilies { 1169 if want, got := fam, familyOf(after.Spec.ClusterIPs[i]); want != got { 1170 t.Errorf("%s: clusterIP is the wrong IP family: want %s, got %s", callName(before, after), want, got) 1171 } 1172 } 1173 1174 if after.Spec.IPFamilyPolicy == nil { 1175 t.Errorf("%s: expected ipFamilyPolicy to be set", callName(before, after)) 1176 } else { 1177 pol := *after.Spec.IPFamilyPolicy 1178 fams := len(after.Spec.IPFamilies) 1179 clus := 1 1180 if storage.secondaryIPFamily != "" { 1181 clus = 2 1182 } 1183 if pol == api.IPFamilyPolicySingleStack && fams != 1 { 1184 t.Errorf("%s: expected 1 ipFamily, got %d", callName(before, after), fams) 1185 } else if pol == api.IPFamilyPolicyRequireDualStack && fams != 2 { 1186 t.Errorf("%s: expected 2 ipFamilies, got %d", callName(before, after), fams) 1187 } else if pol == api.IPFamilyPolicyPreferDualStack && fams != clus { 1188 t.Errorf("%s: expected %d ipFamilies, got %d", callName(before, after), clus, fams) 1189 } 1190 } 1191 1192 if before != nil { 1193 if before.Spec.ClusterIP != "" { 1194 if want, got := before.Spec.ClusterIP, after.Spec.ClusterIP; want != got { 1195 t.Errorf("%s: wrong clusterIP: wanted %q, got %q", callName(before, after), want, got) 1196 } 1197 } 1198 min := func(x, y int) int { 1199 if x < y { 1200 return x 1201 } 1202 return y 1203 } 1204 for i := 0; i < min(len(before.Spec.ClusterIPs), len(after.Spec.ClusterIPs)); i++ { 1205 if want, got := before.Spec.ClusterIPs[i], after.Spec.ClusterIPs[i]; want != got { 1206 t.Errorf("%s: wrong clusterIPs[%d]: wanted %q, got %q", callName(before, after), i, want, got) 1207 } 1208 } 1209 for i := 0; i < min(len(before.Spec.IPFamilies), len(after.Spec.IPFamilies)); i++ { 1210 if want, got := before.Spec.IPFamilies[i], after.Spec.IPFamilies[i]; want != got { 1211 t.Errorf("%s: wrong ipFamilies[%d]: wanted %q, got %q", callName(before, after), i, want, got) 1212 } 1213 } 1214 } 1215 } 1216 1217 func proveClusterIPsDeallocated(t *testing.T, storage *wrapperRESTForTests, before, after *api.Service) { 1218 t.Helper() 1219 1220 if after != nil && after.Spec.ClusterIP != api.ClusterIPNone { 1221 if after.Spec.ClusterIP != "" { 1222 t.Errorf("%s: expected clusterIP to be unset: %q", callName(before, after), after.Spec.ClusterIP) 1223 } 1224 if len(after.Spec.ClusterIPs) != 0 { 1225 t.Errorf("%s: expected clusterIPs to be unset: %q", callName(before, after), after.Spec.ClusterIPs) 1226 } 1227 } 1228 1229 if before != nil && before.Spec.ClusterIP != api.ClusterIPNone { 1230 for _, clip := range before.Spec.ClusterIPs { 1231 if ipIsAllocated(t, storage.alloc.serviceIPAllocatorsByFamily[familyOf(clip)], clip) { 1232 t.Errorf("%s: expected clusterIP to be deallocated: %q", callName(before, after), clip) 1233 } 1234 } 1235 } 1236 } 1237 1238 func proveHeadless(t *testing.T, storage *wrapperRESTForTests, before, after *api.Service) { 1239 t.Helper() 1240 1241 if sing, plur := after.Spec.ClusterIP, after.Spec.ClusterIPs[0]; sing != plur { 1242 t.Errorf("%s: expected clusterIP == clusterIPs[0]: %q != %q", callName(before, after), sing, plur) 1243 } 1244 if len(after.Spec.ClusterIPs) != 1 || after.Spec.ClusterIPs[0] != api.ClusterIPNone { 1245 t.Errorf("%s: expected clusterIPs to be [%q]: %q", callName(before, after), api.ClusterIPNone, after.Spec.ClusterIPs) 1246 } 1247 } 1248 1249 func proveNodePortsAllocated(t *testing.T, storage *wrapperRESTForTests, before, after *api.Service) { 1250 t.Helper() 1251 1252 for _, p := range after.Spec.Ports { 1253 if !portIsAllocated(t, storage.alloc.serviceNodePorts, p.NodePort) { 1254 t.Errorf("%s: expected nodePort to be allocated: %d", callName(before, after), p.NodePort) 1255 } 1256 } 1257 } 1258 1259 func proveNodePortsDeallocated(t *testing.T, storage *wrapperRESTForTests, before, after *api.Service) { 1260 t.Helper() 1261 1262 if after != nil { 1263 for _, p := range after.Spec.Ports { 1264 if p.NodePort != 0 { 1265 t.Errorf("%s: expected nodePort to be unset: %d", callName(before, after), p.NodePort) 1266 } 1267 } 1268 } 1269 1270 if before != nil { 1271 for _, p := range before.Spec.Ports { 1272 if p.NodePort != 0 && portIsAllocated(t, storage.alloc.serviceNodePorts, p.NodePort) { 1273 t.Errorf("%s: expected nodePort to be deallocated: %d", callName(before, after), p.NodePort) 1274 } 1275 } 1276 } 1277 } 1278 1279 func proveHealthCheckNodePortAllocated(t *testing.T, storage *wrapperRESTForTests, before, after *api.Service) { 1280 t.Helper() 1281 1282 if !portIsAllocated(t, storage.alloc.serviceNodePorts, after.Spec.HealthCheckNodePort) { 1283 t.Errorf("%s: expected healthCheckNodePort to be allocated: %d", callName(before, after), after.Spec.HealthCheckNodePort) 1284 } 1285 } 1286 1287 func proveHealthCheckNodePortDeallocated(t *testing.T, storage *wrapperRESTForTests, before, after *api.Service) { 1288 t.Helper() 1289 1290 if after != nil { 1291 if after.Spec.HealthCheckNodePort != 0 { 1292 t.Errorf("%s: expected healthCheckNodePort to be unset: %d", callName(before, after), after.Spec.HealthCheckNodePort) 1293 } 1294 } 1295 1296 if before != nil { 1297 if before.Spec.HealthCheckNodePort != 0 && portIsAllocated(t, storage.alloc.serviceNodePorts, before.Spec.HealthCheckNodePort) { 1298 t.Errorf("%s: expected healthCheckNodePort to be deallocated: %d", callName(before, after), before.Spec.HealthCheckNodePort) 1299 } 1300 } 1301 } 1302 1303 // 1304 // functional tests of the registry 1305 // 1306 1307 func fmtIPFamilyPolicy(pol *api.IPFamilyPolicy) string { 1308 if pol == nil { 1309 return "<nil>" 1310 } 1311 return string(*pol) 1312 } 1313 1314 func fmtInternalTrafficPolicy(pol *api.ServiceInternalTrafficPolicy) string { 1315 if pol == nil { 1316 return "<nil>" 1317 } 1318 return string(*pol) 1319 } 1320 1321 func fmtIPFamilies(fams []api.IPFamily) string { 1322 if fams == nil { 1323 return "[]" 1324 } 1325 return fmt.Sprintf("%v", fams) 1326 } 1327 1328 // Prove that create ignores IP and IPFamily stuff when type is ExternalName. 1329 func TestCreateIgnoresIPsForExternalName(t *testing.T) { 1330 type testCase struct { 1331 name string 1332 svc *api.Service 1333 expectError bool 1334 } 1335 // These cases were chosen from the full gamut to ensure all "interesting" 1336 // cases are covered. 1337 testCases := []struct { 1338 name string 1339 clusterFamilies []api.IPFamily 1340 cases []testCase 1341 }{{ 1342 name: "singlestack:v6", 1343 clusterFamilies: []api.IPFamily{api.IPv6Protocol}, 1344 cases: []testCase{{ 1345 name: "Policy:unset_Families:unset", 1346 svc: svctest.MakeService("foo"), 1347 }, { 1348 name: "Policy:SingleStack_Families:v6", 1349 svc: svctest.MakeService("foo", 1350 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 1351 svctest.SetIPFamilies(api.IPv6Protocol)), 1352 expectError: true, 1353 }, { 1354 name: "Policy:PreferDualStack_Families:v4v6", 1355 svc: svctest.MakeService("foo", 1356 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 1357 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 1358 expectError: true, 1359 }, { 1360 name: "Policy:RequireDualStack_Families:v6v4", 1361 svc: svctest.MakeService("foo", 1362 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 1363 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 1364 expectError: true, 1365 }}, 1366 }, { 1367 name: "dualstack:v6v4", 1368 clusterFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 1369 cases: []testCase{{ 1370 name: "Policy:unset_Families:unset", 1371 svc: svctest.MakeService("foo"), 1372 }, { 1373 name: "Policy:SingleStack_Families:v6", 1374 svc: svctest.MakeService("foo", 1375 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 1376 svctest.SetIPFamilies(api.IPv6Protocol)), 1377 expectError: true, 1378 }, { 1379 name: "Policy:PreferDualStack_Families:v6v4", 1380 svc: svctest.MakeService("foo", 1381 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 1382 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 1383 expectError: true, 1384 }, { 1385 name: "Policy:RequireDualStack_Families:v4v6", 1386 svc: svctest.MakeService("foo", 1387 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 1388 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 1389 expectError: true, 1390 }}, 1391 }} 1392 1393 for _, otc := range testCases { 1394 t.Run(otc.name, func(t *testing.T) { 1395 storage, _, server := newStorage(t, otc.clusterFamilies) 1396 defer server.Terminate(t) 1397 defer storage.Store.DestroyFunc() 1398 1399 for _, itc := range otc.cases { 1400 t.Run(itc.name, func(t *testing.T) { 1401 // This test is ONLY ExternalName services. 1402 itc.svc.Spec.Type = api.ServiceTypeExternalName 1403 itc.svc.Spec.ExternalName = "example.com" 1404 1405 ctx := genericapirequest.NewDefaultContext() 1406 createdObj, err := storage.Create(ctx, itc.svc, rest.ValidateAllObjectFunc, &metav1.CreateOptions{}) 1407 if itc.expectError && err != nil { 1408 return 1409 } 1410 if err != nil { 1411 t.Fatalf("unexpected error creating service: %v", err) 1412 } 1413 defer storage.Delete(ctx, itc.svc.Name, rest.ValidateAllObjectFunc, &metav1.DeleteOptions{}) 1414 if itc.expectError && err == nil { 1415 t.Fatalf("unexpected success creating service") 1416 } 1417 createdSvc := createdObj.(*api.Service) 1418 1419 if want, got := fmtIPFamilyPolicy(nil), fmtIPFamilyPolicy(createdSvc.Spec.IPFamilyPolicy); want != got { 1420 t.Errorf("wrong IPFamilyPolicy: want %s, got %s", want, got) 1421 } 1422 if want, got := fmtIPFamilies(nil), fmtIPFamilies(createdSvc.Spec.IPFamilies); want != got { 1423 t.Errorf("wrong IPFamilies: want %s, got %s", want, got) 1424 } 1425 if len(createdSvc.Spec.ClusterIP) != 0 { 1426 t.Errorf("expected no clusterIP, got %q", createdSvc.Spec.ClusterIP) 1427 } 1428 if len(createdSvc.Spec.ClusterIPs) != 0 { 1429 t.Errorf("expected no clusterIPs, got %q", createdSvc.Spec.ClusterIPs) 1430 } 1431 }) 1432 } 1433 }) 1434 } 1435 } 1436 1437 // Prove that create initializes clusterIPs from clusterIP. This simplifies 1438 // later tests to not need to re-prove this. 1439 func TestCreateInitClusterIPsFromClusterIP(t *testing.T) { 1440 testCases := []struct { 1441 name string 1442 clusterFamilies []api.IPFamily 1443 svc *api.Service 1444 }{{ 1445 name: "singlestack:v4_clusterip:unset", 1446 clusterFamilies: []api.IPFamily{api.IPv4Protocol}, 1447 svc: svctest.MakeService("foo"), 1448 }, { 1449 name: "singlestack:v4_clusterip:set", 1450 clusterFamilies: []api.IPFamily{api.IPv4Protocol}, 1451 svc: svctest.MakeService("foo", 1452 svctest.SetClusterIP("10.0.0.1")), 1453 }, { 1454 name: "singlestack:v6_clusterip:unset", 1455 clusterFamilies: []api.IPFamily{api.IPv6Protocol}, 1456 svc: svctest.MakeService("foo"), 1457 }, { 1458 name: "singlestack:v6_clusterip:set", 1459 clusterFamilies: []api.IPFamily{api.IPv6Protocol}, 1460 svc: svctest.MakeService("foo", 1461 svctest.SetClusterIP("2000::1")), 1462 }, { 1463 name: "dualstack:v4v6_clusterip:unset", 1464 clusterFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 1465 svc: svctest.MakeService("foo"), 1466 }, { 1467 name: "dualstack:v4v6_clusterip:set", 1468 clusterFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 1469 svc: svctest.MakeService("foo", 1470 svctest.SetClusterIP("10.0.0.1")), 1471 }, { 1472 name: "dualstack:v6v4_clusterip:unset", 1473 clusterFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 1474 svc: svctest.MakeService("foo"), 1475 }, { 1476 name: "dualstack:v6v4_clusterip:set", 1477 clusterFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 1478 svc: svctest.MakeService("foo", 1479 svctest.SetClusterIP("2000::1")), 1480 }} 1481 1482 for _, tc := range testCases { 1483 t.Run(tc.name, func(t *testing.T) { 1484 storage, _, server := newStorage(t, tc.clusterFamilies) 1485 defer server.Terminate(t) 1486 defer storage.Store.DestroyFunc() 1487 1488 ctx := genericapirequest.NewDefaultContext() 1489 createdObj, err := storage.Create(ctx, tc.svc, rest.ValidateAllObjectFunc, &metav1.CreateOptions{}) 1490 if err != nil { 1491 t.Fatalf("unexpected error creating service: %v", err) 1492 } 1493 createdSvc := createdObj.(*api.Service) 1494 1495 if createdSvc.Spec.ClusterIP == "" { 1496 t.Errorf("expected ClusterIP to be set") 1497 1498 } 1499 if tc.svc.Spec.ClusterIP != "" { 1500 if want, got := tc.svc.Spec.ClusterIP, createdSvc.Spec.ClusterIP; want != got { 1501 t.Errorf("wrong ClusterIP: want %s, got %s", want, got) 1502 } 1503 } 1504 if len(createdSvc.Spec.ClusterIPs) == 0 { 1505 t.Errorf("expected ClusterIPs to be set") 1506 } 1507 if want, got := createdSvc.Spec.ClusterIP, createdSvc.Spec.ClusterIPs[0]; want != got { 1508 t.Errorf("wrong ClusterIPs[0]: want %s, got %s", want, got) 1509 } 1510 }) 1511 } 1512 } 1513 1514 // Prove that create initializes IPFamily fields correctly. 1515 func TestCreateInitIPFields(t *testing.T) { 1516 type testCase struct { 1517 name string 1518 line string 1519 svc *api.Service 1520 expectError bool 1521 expectPolicy api.IPFamilyPolicy 1522 expectFamilies []api.IPFamily 1523 expectHeadless bool 1524 } 1525 // These cases were chosen from the full gamut to ensure all "interesting" 1526 // cases are covered. 1527 testCases := []struct { 1528 name string 1529 clusterFamilies []api.IPFamily 1530 cases []testCase 1531 }{ 1532 { 1533 name: "singlestack:v4", 1534 clusterFamilies: []api.IPFamily{api.IPv4Protocol}, 1535 cases: []testCase{ 1536 //---------------------------------------- 1537 // singlestack:v4 ClusterIPs:unset 1538 //---------------------------------------- 1539 { 1540 name: "ClusterIPs:unset_Policy:unset_Families:unset", 1541 line: line(), 1542 svc: svctest.MakeService("foo"), 1543 expectPolicy: api.IPFamilyPolicySingleStack, 1544 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 1545 }, { 1546 name: "ClusterIPs:unset_Policy:unset_Families:v4", 1547 line: line(), 1548 svc: svctest.MakeService("foo", 1549 svctest.SetIPFamilies(api.IPv4Protocol)), 1550 expectPolicy: api.IPFamilyPolicySingleStack, 1551 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 1552 }, { 1553 name: "ClusterIPs:unset_Policy:unset_Families:v6", 1554 line: line(), 1555 svc: svctest.MakeService("foo", 1556 svctest.SetIPFamilies(api.IPv6Protocol)), 1557 expectError: true, 1558 }, { 1559 name: "ClusterIPs:unset_Policy:unset_Families:v4v6", 1560 line: line(), 1561 svc: svctest.MakeService("foo", 1562 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 1563 expectError: true, 1564 }, { 1565 name: "ClusterIPs:unset_Policy:unset_Families:v6v4", 1566 line: line(), 1567 svc: svctest.MakeService("foo", 1568 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 1569 expectError: true, 1570 }, { 1571 name: "ClusterIPs:unset_Policy:SingleStack_Families:unset", 1572 line: line(), 1573 svc: svctest.MakeService("foo", 1574 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack)), 1575 expectPolicy: api.IPFamilyPolicySingleStack, 1576 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 1577 }, { 1578 name: "ClusterIPs:unset_Policy:SingleStack_Families:v4", 1579 line: line(), 1580 svc: svctest.MakeService("foo", 1581 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 1582 svctest.SetIPFamilies(api.IPv4Protocol)), 1583 expectPolicy: api.IPFamilyPolicySingleStack, 1584 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 1585 }, { 1586 name: "ClusterIPs:unset_Policy:SingleStack_Families:v6", 1587 line: line(), 1588 svc: svctest.MakeService("foo", 1589 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 1590 svctest.SetIPFamilies(api.IPv6Protocol)), 1591 expectError: true, 1592 }, { 1593 name: "ClusterIPs:unset_Policy:SingleStack_Families:v4v6", 1594 line: line(), 1595 svc: svctest.MakeService("foo", 1596 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 1597 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 1598 expectError: true, 1599 }, { 1600 name: "ClusterIPs:unset_Policy:SingleStack_Families:v6v4", 1601 line: line(), 1602 svc: svctest.MakeService("foo", 1603 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 1604 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 1605 expectError: true, 1606 }, { 1607 name: "ClusterIPs:unset_Policy:PreferDualStack_Families:unset", 1608 line: line(), 1609 svc: svctest.MakeService("foo", 1610 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack)), 1611 expectPolicy: api.IPFamilyPolicyPreferDualStack, 1612 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 1613 }, { 1614 name: "ClusterIPs:unset_Policy:PreferDualStack_Families:v4", 1615 line: line(), 1616 svc: svctest.MakeService("foo", 1617 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 1618 svctest.SetIPFamilies(api.IPv4Protocol)), 1619 expectPolicy: api.IPFamilyPolicyPreferDualStack, 1620 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 1621 }, { 1622 name: "ClusterIPs:unset_Policy:PreferDualStack_Families:v6", 1623 line: line(), 1624 svc: svctest.MakeService("foo", 1625 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 1626 svctest.SetIPFamilies(api.IPv6Protocol)), 1627 expectError: true, 1628 }, { 1629 name: "ClusterIPs:unset_Policy:PreferDualStack_Families:v4v6", 1630 line: line(), 1631 svc: svctest.MakeService("foo", 1632 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 1633 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 1634 expectError: true, 1635 }, { 1636 name: "ClusterIPs:unset_Policy:PreferDualStack_Families:v6v4", 1637 line: line(), 1638 svc: svctest.MakeService("foo", 1639 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 1640 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 1641 expectError: true, 1642 }, { 1643 name: "ClusterIPs:unset_Policy:RequireDualStack_Families:unset", 1644 line: line(), 1645 svc: svctest.MakeService("foo", 1646 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack)), 1647 expectError: true, 1648 }, { 1649 name: "ClusterIPs:unset_Policy:RequireDualStack_Families:v4", 1650 line: line(), 1651 svc: svctest.MakeService("foo", 1652 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 1653 svctest.SetIPFamilies(api.IPv4Protocol)), 1654 expectError: true, 1655 }, { 1656 name: "ClusterIPs:unset_Policy:RequireDualStack_Families:v6", 1657 line: line(), 1658 svc: svctest.MakeService("foo", 1659 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 1660 svctest.SetIPFamilies(api.IPv6Protocol)), 1661 expectError: true, 1662 }, { 1663 name: "ClusterIPs:unset_Policy:RequireDualStack_Families:v4v6", 1664 line: line(), 1665 svc: svctest.MakeService("foo", 1666 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 1667 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 1668 expectError: true, 1669 }, { 1670 name: "ClusterIPs:unset_Policy:RequireDualStack_Families:v6v4", 1671 line: line(), 1672 svc: svctest.MakeService("foo", 1673 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 1674 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 1675 expectError: true, 1676 }, 1677 //---------------------------------------- 1678 // singlestack:v4 ClusterIPs:v4 1679 //---------------------------------------- 1680 { 1681 name: "ClusterIPs:v4_Policy:unset_Families:unset", 1682 line: line(), 1683 svc: svctest.MakeService("foo", 1684 svctest.SetClusterIPs("10.0.0.1")), 1685 expectPolicy: api.IPFamilyPolicySingleStack, 1686 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 1687 }, { 1688 name: "ClusterIPs:v4_Policy:unset_Families:v4", 1689 line: line(), 1690 svc: svctest.MakeService("foo", 1691 svctest.SetClusterIPs("10.0.0.1"), 1692 svctest.SetIPFamilies(api.IPv4Protocol)), 1693 expectPolicy: api.IPFamilyPolicySingleStack, 1694 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 1695 }, { 1696 name: "ClusterIPs:v4_Policy:unset_Families:v6", 1697 line: line(), 1698 svc: svctest.MakeService("foo", 1699 svctest.SetClusterIPs("10.0.0.1"), 1700 svctest.SetIPFamilies(api.IPv6Protocol)), 1701 expectError: true, 1702 }, { 1703 name: "ClusterIPs:v4_Policy:unset_Families:v4v6", 1704 line: line(), 1705 svc: svctest.MakeService("foo", 1706 svctest.SetClusterIPs("10.0.0.1"), 1707 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 1708 expectError: true, 1709 }, { 1710 name: "ClusterIPs:v4_Policy:unset_Families:v6v4", 1711 line: line(), 1712 svc: svctest.MakeService("foo", 1713 svctest.SetClusterIPs("10.0.0.1"), 1714 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 1715 expectError: true, 1716 }, { 1717 name: "ClusterIPs:v4_Policy:SingleStack_Families:unset", 1718 line: line(), 1719 svc: svctest.MakeService("foo", 1720 svctest.SetClusterIPs("10.0.0.1"), 1721 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack)), 1722 expectPolicy: api.IPFamilyPolicySingleStack, 1723 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 1724 }, { 1725 name: "ClusterIPs:v4_Policy:SingleStack_Families:v4", 1726 line: line(), 1727 svc: svctest.MakeService("foo", 1728 svctest.SetClusterIPs("10.0.0.1"), 1729 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 1730 svctest.SetIPFamilies(api.IPv4Protocol)), 1731 expectPolicy: api.IPFamilyPolicySingleStack, 1732 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 1733 }, { 1734 name: "ClusterIPs:v4_Policy:SingleStack_Families:v6", 1735 line: line(), 1736 svc: svctest.MakeService("foo", 1737 svctest.SetClusterIPs("10.0.0.1"), 1738 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 1739 svctest.SetIPFamilies(api.IPv6Protocol)), 1740 expectError: true, 1741 }, { 1742 name: "ClusterIPs:v4_Policy:SingleStack_Families:v4v6", 1743 line: line(), 1744 svc: svctest.MakeService("foo", 1745 svctest.SetClusterIPs("10.0.0.1"), 1746 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 1747 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 1748 expectError: true, 1749 }, { 1750 name: "ClusterIPs:v4_Policy:SingleStack_Families:v6v4", 1751 line: line(), 1752 svc: svctest.MakeService("foo", 1753 svctest.SetClusterIPs("10.0.0.1"), 1754 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 1755 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 1756 expectError: true, 1757 }, { 1758 name: "ClusterIPs:v4_Policy:PreferDualStack_Families:unset", 1759 line: line(), 1760 svc: svctest.MakeService("foo", 1761 svctest.SetClusterIPs("10.0.0.1"), 1762 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack)), 1763 expectPolicy: api.IPFamilyPolicyPreferDualStack, 1764 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 1765 }, { 1766 name: "ClusterIPs:v4_Policy:PreferDualStack_Families:v4", 1767 line: line(), 1768 svc: svctest.MakeService("foo", 1769 svctest.SetClusterIPs("10.0.0.1"), 1770 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 1771 svctest.SetIPFamilies(api.IPv4Protocol)), 1772 expectPolicy: api.IPFamilyPolicyPreferDualStack, 1773 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 1774 }, { 1775 name: "ClusterIPs:v4_Policy:PreferDualStack_Families:v6", 1776 line: line(), 1777 svc: svctest.MakeService("foo", 1778 svctest.SetClusterIPs("10.0.0.1"), 1779 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 1780 svctest.SetIPFamilies(api.IPv6Protocol)), 1781 expectError: true, 1782 }, { 1783 name: "ClusterIPs:v4_Policy:PreferDualStack_Families:v4v6", 1784 line: line(), 1785 svc: svctest.MakeService("foo", 1786 svctest.SetClusterIPs("10.0.0.1"), 1787 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 1788 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 1789 expectError: true, 1790 }, { 1791 name: "ClusterIPs:v4_Policy:PreferDualStack_Families:v6v4", 1792 line: line(), 1793 svc: svctest.MakeService("foo", 1794 svctest.SetClusterIPs("10.0.0.1"), 1795 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 1796 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 1797 expectError: true, 1798 }, { 1799 name: "ClusterIPs:v4_Policy:RequireDualStack_Families:unset", 1800 line: line(), 1801 svc: svctest.MakeService("foo", 1802 svctest.SetClusterIPs("10.0.0.1"), 1803 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack)), 1804 expectError: true, 1805 }, { 1806 name: "ClusterIPs:v4_Policy:RequireDualStack_Families:v4", 1807 line: line(), 1808 svc: svctest.MakeService("foo", 1809 svctest.SetClusterIPs("10.0.0.1"), 1810 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 1811 svctest.SetIPFamilies(api.IPv4Protocol)), 1812 expectError: true, 1813 }, { 1814 name: "ClusterIPs:v4_Policy:RequireDualStack_Families:v6", 1815 line: line(), 1816 svc: svctest.MakeService("foo", 1817 svctest.SetClusterIPs("10.0.0.1"), 1818 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 1819 svctest.SetIPFamilies(api.IPv6Protocol)), 1820 expectError: true, 1821 }, { 1822 name: "ClusterIPs:v4_Policy:RequireDualStack_Families:v4v6", 1823 line: line(), 1824 svc: svctest.MakeService("foo", 1825 svctest.SetClusterIPs("10.0.0.1"), 1826 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 1827 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 1828 expectError: true, 1829 }, { 1830 name: "ClusterIPs:v4_Policy:RequireDualStack_Families:v6v4", 1831 line: line(), 1832 svc: svctest.MakeService("foo", 1833 svctest.SetClusterIPs("10.0.0.1"), 1834 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 1835 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 1836 expectError: true, 1837 }, 1838 //---------------------------------------- 1839 // singlestack:v4 ClusterIPs:v4v6 1840 //---------------------------------------- 1841 { 1842 name: "ClusterIPs:v4v6_Policy:unset_Families:unset", 1843 line: line(), 1844 svc: svctest.MakeService("foo", 1845 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 1846 expectError: true, 1847 }, { 1848 name: "ClusterIPs:v4v6_Policy:unset_Families:v4", 1849 line: line(), 1850 svc: svctest.MakeService("foo", 1851 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 1852 svctest.SetIPFamilies(api.IPv4Protocol)), 1853 expectError: true, 1854 }, { 1855 name: "ClusterIPs:v4v6_Policy:unset_Families:v6", 1856 line: line(), 1857 svc: svctest.MakeService("foo", 1858 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 1859 svctest.SetIPFamilies(api.IPv6Protocol)), 1860 expectError: true, 1861 }, { 1862 name: "ClusterIPs:v4v6_Policy:unset_Families:v4v6", 1863 line: line(), 1864 svc: svctest.MakeService("foo", 1865 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 1866 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 1867 expectError: true, 1868 }, { 1869 name: "ClusterIPs:v4v6_Policy:unset_Families:v6v4", 1870 line: line(), 1871 svc: svctest.MakeService("foo", 1872 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 1873 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 1874 expectError: true, 1875 }, { 1876 name: "ClusterIPs:v4v6_Policy:SingleStack_Families:unset", 1877 line: line(), 1878 svc: svctest.MakeService("foo", 1879 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 1880 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack)), 1881 expectError: true, 1882 }, { 1883 name: "ClusterIPs:v4v6_Policy:SingleStack_Families:v4", 1884 line: line(), 1885 svc: svctest.MakeService("foo", 1886 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 1887 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 1888 svctest.SetIPFamilies(api.IPv4Protocol)), 1889 expectError: true, 1890 }, { 1891 name: "ClusterIPs:v4v6_Policy:SingleStack_Families:v6", 1892 line: line(), 1893 svc: svctest.MakeService("foo", 1894 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 1895 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 1896 svctest.SetIPFamilies(api.IPv6Protocol)), 1897 expectError: true, 1898 }, { 1899 name: "ClusterIPs:v4v6_Policy:SingleStack_Families:v4v6", 1900 line: line(), 1901 svc: svctest.MakeService("foo", 1902 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 1903 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 1904 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 1905 expectError: true, 1906 }, { 1907 name: "ClusterIPs:v4v6_Policy:SingleStack_Families:v6v4", 1908 line: line(), 1909 svc: svctest.MakeService("foo", 1910 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 1911 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 1912 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 1913 expectError: true, 1914 }, { 1915 name: "ClusterIPs:v4v6_Policy:PreferDualStack_Families:unset", 1916 line: line(), 1917 svc: svctest.MakeService("foo", 1918 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 1919 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack)), 1920 expectError: true, 1921 }, { 1922 name: "ClusterIPs:v4v6_Policy:PreferDualStack_Families:v4", 1923 line: line(), 1924 svc: svctest.MakeService("foo", 1925 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 1926 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 1927 svctest.SetIPFamilies(api.IPv4Protocol)), 1928 expectError: true, 1929 }, { 1930 name: "ClusterIPs:v4v6_Policy:PreferDualStack_Families:v6", 1931 line: line(), 1932 svc: svctest.MakeService("foo", 1933 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 1934 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 1935 svctest.SetIPFamilies(api.IPv6Protocol)), 1936 expectError: true, 1937 }, { 1938 name: "ClusterIPs:v4v6_Policy:PreferDualStack_Families:v4v6", 1939 line: line(), 1940 svc: svctest.MakeService("foo", 1941 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 1942 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 1943 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 1944 expectError: true, 1945 }, { 1946 name: "ClusterIPs:v4v6_Policy:PreferDualStack_Families:v6v4", 1947 line: line(), 1948 svc: svctest.MakeService("foo", 1949 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 1950 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 1951 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 1952 expectError: true, 1953 }, { 1954 name: "ClusterIPs:v4v6_Policy:RequireDualStack_Families:unset", 1955 line: line(), 1956 svc: svctest.MakeService("foo", 1957 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 1958 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack)), 1959 expectError: true, 1960 }, { 1961 name: "ClusterIPs:v4v6_Policy:RequireDualStack_Families:v4", 1962 line: line(), 1963 svc: svctest.MakeService("foo", 1964 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 1965 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 1966 svctest.SetIPFamilies(api.IPv4Protocol)), 1967 expectError: true, 1968 }, { 1969 name: "ClusterIPs:v4v6_Policy:RequireDualStack_Families:v6", 1970 line: line(), 1971 svc: svctest.MakeService("foo", 1972 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 1973 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 1974 svctest.SetIPFamilies(api.IPv6Protocol)), 1975 expectError: true, 1976 }, { 1977 name: "ClusterIPs:v4v6_Policy:RequireDualStack_Families:v4v6", 1978 line: line(), 1979 svc: svctest.MakeService("foo", 1980 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 1981 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 1982 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 1983 expectError: true, 1984 }, { 1985 name: "ClusterIPs:v4v6_Policy:RequireDualStack_Families:v6v4", 1986 line: line(), 1987 svc: svctest.MakeService("foo", 1988 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 1989 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 1990 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 1991 expectError: true, 1992 }, 1993 //---------------------------------------- 1994 // singlestack:v4 ClusterIPs:v6v4 1995 //---------------------------------------- 1996 { 1997 name: "ClusterIPs:v6v4_Policy:unset_Families:unset", 1998 line: line(), 1999 svc: svctest.MakeService("foo", 2000 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 2001 expectError: true, 2002 }, { 2003 name: "ClusterIPs:v6v4_Policy:unset_Families:v4", 2004 line: line(), 2005 svc: svctest.MakeService("foo", 2006 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 2007 svctest.SetIPFamilies(api.IPv4Protocol)), 2008 expectError: true, 2009 }, { 2010 name: "ClusterIPs:v6v4_Policy:unset_Families:v6", 2011 line: line(), 2012 svc: svctest.MakeService("foo", 2013 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 2014 svctest.SetIPFamilies(api.IPv6Protocol)), 2015 expectError: true, 2016 }, { 2017 name: "ClusterIPs:v6v4_Policy:unset_Families:v4v6", 2018 line: line(), 2019 svc: svctest.MakeService("foo", 2020 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 2021 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 2022 expectError: true, 2023 }, { 2024 name: "ClusterIPs:v6v4_Policy:unset_Families:v6v4", 2025 line: line(), 2026 svc: svctest.MakeService("foo", 2027 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 2028 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 2029 expectError: true, 2030 }, { 2031 name: "ClusterIPs:v6v4_Policy:SingleStack_Families:unset", 2032 line: line(), 2033 svc: svctest.MakeService("foo", 2034 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 2035 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack)), 2036 expectError: true, 2037 }, { 2038 name: "ClusterIPs:v6v4_Policy:SingleStack_Families:v4", 2039 line: line(), 2040 svc: svctest.MakeService("foo", 2041 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 2042 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 2043 svctest.SetIPFamilies(api.IPv4Protocol)), 2044 expectError: true, 2045 }, { 2046 name: "ClusterIPs:v6v4_Policy:SingleStack_Families:v6", 2047 line: line(), 2048 svc: svctest.MakeService("foo", 2049 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 2050 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 2051 svctest.SetIPFamilies(api.IPv6Protocol)), 2052 expectError: true, 2053 }, { 2054 name: "ClusterIPs:v6v4_Policy:SingleStack_Families:v4v6", 2055 line: line(), 2056 svc: svctest.MakeService("foo", 2057 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 2058 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 2059 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 2060 expectError: true, 2061 }, { 2062 name: "ClusterIPs:v6v4_Policy:SingleStack_Families:v6v4", 2063 line: line(), 2064 svc: svctest.MakeService("foo", 2065 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 2066 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 2067 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 2068 expectError: true, 2069 }, { 2070 name: "ClusterIPs:v6v4_Policy:PreferDualStack_Families:unset", 2071 line: line(), 2072 svc: svctest.MakeService("foo", 2073 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 2074 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack)), 2075 expectError: true, 2076 }, { 2077 name: "ClusterIPs:v6v4_Policy:PreferDualStack_Families:v4", 2078 line: line(), 2079 svc: svctest.MakeService("foo", 2080 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 2081 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 2082 svctest.SetIPFamilies(api.IPv4Protocol)), 2083 expectError: true, 2084 }, { 2085 name: "ClusterIPs:v6v4_Policy:PreferDualStack_Families:v6", 2086 line: line(), 2087 svc: svctest.MakeService("foo", 2088 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 2089 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 2090 svctest.SetIPFamilies(api.IPv6Protocol)), 2091 expectError: true, 2092 }, { 2093 name: "ClusterIPs:v6v4_Policy:PreferDualStack_Families:v4v6", 2094 line: line(), 2095 svc: svctest.MakeService("foo", 2096 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 2097 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 2098 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 2099 expectError: true, 2100 }, { 2101 name: "ClusterIPs:v6v4_Policy:PreferDualStack_Families:v6v4", 2102 line: line(), 2103 svc: svctest.MakeService("foo", 2104 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 2105 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 2106 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 2107 expectError: true, 2108 }, { 2109 name: "ClusterIPs:v6v4_Policy:RequireDualStack_Families:unset", 2110 line: line(), 2111 svc: svctest.MakeService("foo", 2112 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 2113 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack)), 2114 expectError: true, 2115 }, { 2116 name: "ClusterIPs:v6v4_Policy:RequireDualStack_Families:v4", 2117 line: line(), 2118 svc: svctest.MakeService("foo", 2119 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 2120 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 2121 svctest.SetIPFamilies(api.IPv4Protocol)), 2122 expectError: true, 2123 }, { 2124 name: "ClusterIPs:v6v4_Policy:RequireDualStack_Families:v6", 2125 line: line(), 2126 svc: svctest.MakeService("foo", 2127 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 2128 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 2129 svctest.SetIPFamilies(api.IPv6Protocol)), 2130 expectError: true, 2131 }, { 2132 name: "ClusterIPs:v6v4_Policy:RequireDualStack_Families:v4v6", 2133 line: line(), 2134 svc: svctest.MakeService("foo", 2135 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 2136 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 2137 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 2138 expectError: true, 2139 }, { 2140 name: "ClusterIPs:v6v4_Policy:RequireDualStack_Families:v6v4", 2141 line: line(), 2142 svc: svctest.MakeService("foo", 2143 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 2144 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 2145 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 2146 expectError: true, 2147 }, 2148 //---------------------------------------- 2149 // singlestack:v4 Headless 2150 //---------------------------------------- 2151 { 2152 name: "Headless_Policy:unset_Families:unset", 2153 line: line(), 2154 svc: svctest.MakeService("foo", 2155 svctest.SetHeadless), 2156 expectPolicy: api.IPFamilyPolicySingleStack, 2157 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 2158 expectHeadless: true, 2159 }, { 2160 name: "Headless_Policy:unset_Families:v4", 2161 line: line(), 2162 svc: svctest.MakeService("foo", 2163 svctest.SetHeadless, 2164 svctest.SetIPFamilies(api.IPv4Protocol)), 2165 expectPolicy: api.IPFamilyPolicySingleStack, 2166 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 2167 expectHeadless: true, 2168 }, { 2169 name: "Headless_Policy:unset_Families:v6", 2170 line: line(), 2171 svc: svctest.MakeService("foo", 2172 svctest.SetHeadless, 2173 svctest.SetIPFamilies(api.IPv6Protocol)), 2174 expectError: true, 2175 }, { 2176 name: "Headless_Policy:unset_Families:v4v6", 2177 line: line(), 2178 svc: svctest.MakeService("foo", 2179 svctest.SetHeadless, 2180 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 2181 expectError: true, 2182 }, { 2183 name: "Headless_Policy:unset_Families:v6v4", 2184 line: line(), 2185 svc: svctest.MakeService("foo", 2186 svctest.SetHeadless, 2187 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 2188 expectError: true, 2189 }, { 2190 name: "Headless_Policy:SingleStack_Families:unset", 2191 line: line(), 2192 svc: svctest.MakeService("foo", 2193 svctest.SetHeadless, 2194 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack)), 2195 expectPolicy: api.IPFamilyPolicySingleStack, 2196 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 2197 expectHeadless: true, 2198 }, { 2199 name: "Headless_Policy:SingleStack_Families:v4", 2200 line: line(), 2201 svc: svctest.MakeService("foo", 2202 svctest.SetHeadless, 2203 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 2204 svctest.SetIPFamilies(api.IPv4Protocol)), 2205 expectPolicy: api.IPFamilyPolicySingleStack, 2206 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 2207 expectHeadless: true, 2208 }, { 2209 name: "Headless_Policy:SingleStack_Families:v6", 2210 line: line(), 2211 svc: svctest.MakeService("foo", 2212 svctest.SetHeadless, 2213 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 2214 svctest.SetIPFamilies(api.IPv6Protocol)), 2215 expectError: true, 2216 }, { 2217 name: "Headless_Policy:SingleStack_Families:v4v6", 2218 line: line(), 2219 svc: svctest.MakeService("foo", 2220 svctest.SetHeadless, 2221 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 2222 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 2223 expectError: true, 2224 }, { 2225 name: "Headless_Policy:SingleStack_Families:v6v4", 2226 line: line(), 2227 svc: svctest.MakeService("foo", 2228 svctest.SetHeadless, 2229 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 2230 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 2231 expectError: true, 2232 }, { 2233 name: "Headless_Policy:PreferDualStack_Families:unset", 2234 line: line(), 2235 svc: svctest.MakeService("foo", 2236 svctest.SetHeadless, 2237 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack)), 2238 expectPolicy: api.IPFamilyPolicyPreferDualStack, 2239 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 2240 expectHeadless: true, 2241 }, { 2242 name: "Headless_Policy:PreferDualStack_Families:v4", 2243 line: line(), 2244 svc: svctest.MakeService("foo", 2245 svctest.SetHeadless, 2246 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 2247 svctest.SetIPFamilies(api.IPv4Protocol)), 2248 expectPolicy: api.IPFamilyPolicyPreferDualStack, 2249 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 2250 expectHeadless: true, 2251 }, { 2252 name: "Headless_Policy:PreferDualStack_Families:v6", 2253 line: line(), 2254 svc: svctest.MakeService("foo", 2255 svctest.SetHeadless, 2256 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 2257 svctest.SetIPFamilies(api.IPv6Protocol)), 2258 expectError: true, 2259 }, { 2260 name: "Headless_Policy:PreferDualStack_Families:v4v6", 2261 line: line(), 2262 svc: svctest.MakeService("foo", 2263 svctest.SetHeadless, 2264 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 2265 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 2266 expectError: true, 2267 }, { 2268 name: "Headless_Policy:PreferDualStack_Families:v6v4", 2269 line: line(), 2270 svc: svctest.MakeService("foo", 2271 svctest.SetHeadless, 2272 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 2273 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 2274 expectError: true, 2275 }, { 2276 name: "Headless_Policy:RequireDualStack_Families:unset", 2277 line: line(), 2278 svc: svctest.MakeService("foo", 2279 svctest.SetHeadless, 2280 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack)), 2281 expectError: true, 2282 }, { 2283 name: "Headless_Policy:RequireDualStack_Families:v4", 2284 line: line(), 2285 svc: svctest.MakeService("foo", 2286 svctest.SetHeadless, 2287 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 2288 svctest.SetIPFamilies(api.IPv4Protocol)), 2289 expectError: true, 2290 }, { 2291 name: "Headless_Policy:RequireDualStack_Families:v6", 2292 line: line(), 2293 svc: svctest.MakeService("foo", 2294 svctest.SetHeadless, 2295 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 2296 svctest.SetIPFamilies(api.IPv6Protocol)), 2297 expectError: true, 2298 }, { 2299 name: "Headless_Policy:RequireDualStack_Families:v4v6", 2300 line: line(), 2301 svc: svctest.MakeService("foo", 2302 svctest.SetHeadless, 2303 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 2304 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 2305 expectError: true, 2306 }, { 2307 name: "Headless_Policy:RequireDualStack_Families:v6v4", 2308 line: line(), 2309 svc: svctest.MakeService("foo", 2310 svctest.SetHeadless, 2311 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 2312 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 2313 expectError: true, 2314 }, 2315 //---------------------------------------- 2316 // singlestack:v4 HeadlessSelectorless 2317 //---------------------------------------- 2318 { 2319 name: "HeadlessSelectorless_Policy:unset_Families:unset", 2320 line: line(), 2321 svc: svctest.MakeService("foo", 2322 svctest.SetHeadless, 2323 svctest.SetSelector(nil)), 2324 expectPolicy: api.IPFamilyPolicyRequireDualStack, 2325 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 2326 expectHeadless: true, 2327 }, { 2328 name: "HeadlessSelectorless_Policy:unset_Families:v4", 2329 line: line(), 2330 svc: svctest.MakeService("foo", 2331 svctest.SetHeadless, 2332 svctest.SetSelector(nil), 2333 svctest.SetIPFamilies(api.IPv4Protocol)), 2334 expectPolicy: api.IPFamilyPolicyRequireDualStack, 2335 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 2336 expectHeadless: true, 2337 }, { 2338 name: "HeadlessSelectorless_Policy:unset_Families:v6", 2339 line: line(), 2340 svc: svctest.MakeService("foo", 2341 svctest.SetHeadless, 2342 svctest.SetSelector(nil), 2343 svctest.SetIPFamilies(api.IPv6Protocol)), 2344 expectPolicy: api.IPFamilyPolicyRequireDualStack, 2345 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 2346 expectHeadless: true, 2347 }, { 2348 name: "HeadlessSelectorless_Policy:unset_Families:v4v6", 2349 line: line(), 2350 svc: svctest.MakeService("foo", 2351 svctest.SetHeadless, 2352 svctest.SetSelector(nil), 2353 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 2354 expectPolicy: api.IPFamilyPolicyRequireDualStack, 2355 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 2356 expectHeadless: true, 2357 }, { 2358 name: "HeadlessSelectorless_Policy:unset_Families:v6v4", 2359 line: line(), 2360 svc: svctest.MakeService("foo", 2361 svctest.SetHeadless, 2362 svctest.SetSelector(nil), 2363 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 2364 expectPolicy: api.IPFamilyPolicyRequireDualStack, 2365 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 2366 expectHeadless: true, 2367 }, { 2368 name: "HeadlessSelectorless_Policy:SingleStack_Families:unset", 2369 line: line(), 2370 svc: svctest.MakeService("foo", 2371 svctest.SetHeadless, 2372 svctest.SetSelector(nil), 2373 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack)), 2374 expectPolicy: api.IPFamilyPolicySingleStack, 2375 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 2376 expectHeadless: true, 2377 }, { 2378 name: "HeadlessSelectorless_Policy:SingleStack_Families:v4", 2379 line: line(), 2380 svc: svctest.MakeService("foo", 2381 svctest.SetHeadless, 2382 svctest.SetSelector(nil), 2383 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 2384 svctest.SetIPFamilies(api.IPv4Protocol)), 2385 expectPolicy: api.IPFamilyPolicySingleStack, 2386 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 2387 expectHeadless: true, 2388 }, { 2389 name: "HeadlessSelectorless_Policy:SingleStack_Families:v6", 2390 line: line(), 2391 svc: svctest.MakeService("foo", 2392 svctest.SetHeadless, 2393 svctest.SetSelector(nil), 2394 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 2395 svctest.SetIPFamilies(api.IPv6Protocol)), 2396 expectPolicy: api.IPFamilyPolicySingleStack, 2397 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 2398 expectHeadless: true, 2399 }, { 2400 name: "HeadlessSelectorless_Policy:SingleStack_Families:v4v6", 2401 line: line(), 2402 svc: svctest.MakeService("foo", 2403 svctest.SetHeadless, 2404 svctest.SetSelector(nil), 2405 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 2406 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 2407 expectError: true, 2408 }, { 2409 name: "HeadlessSelectorless_Policy:SingleStack_Families:v6v4", 2410 line: line(), 2411 svc: svctest.MakeService("foo", 2412 svctest.SetHeadless, 2413 svctest.SetSelector(nil), 2414 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 2415 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 2416 expectError: true, 2417 }, { 2418 name: "HeadlessSelectorless_Policy:PreferDualStack_Families:unset", 2419 line: line(), 2420 svc: svctest.MakeService("foo", 2421 svctest.SetHeadless, 2422 svctest.SetSelector(nil), 2423 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack)), 2424 expectPolicy: api.IPFamilyPolicyPreferDualStack, 2425 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 2426 expectHeadless: true, 2427 }, { 2428 name: "HeadlessSelectorless_Policy:PreferDualStack_Families:v4", 2429 line: line(), 2430 svc: svctest.MakeService("foo", 2431 svctest.SetHeadless, 2432 svctest.SetSelector(nil), 2433 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 2434 svctest.SetIPFamilies(api.IPv4Protocol)), 2435 expectPolicy: api.IPFamilyPolicyPreferDualStack, 2436 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 2437 expectHeadless: true, 2438 }, { 2439 name: "HeadlessSelectorless_Policy:PreferDualStack_Families:v6", 2440 line: line(), 2441 svc: svctest.MakeService("foo", 2442 svctest.SetHeadless, 2443 svctest.SetSelector(nil), 2444 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 2445 svctest.SetIPFamilies(api.IPv6Protocol)), 2446 expectPolicy: api.IPFamilyPolicyPreferDualStack, 2447 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 2448 expectHeadless: true, 2449 }, { 2450 name: "HeadlessSelectorless_Policy:PreferDualStack_Families:v4v6", 2451 line: line(), 2452 svc: svctest.MakeService("foo", 2453 svctest.SetHeadless, 2454 svctest.SetSelector(nil), 2455 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 2456 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 2457 expectPolicy: api.IPFamilyPolicyPreferDualStack, 2458 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 2459 expectHeadless: true, 2460 }, { 2461 name: "HeadlessSelectorless_Policy:PreferDualStack_Families:v6v4", 2462 line: line(), 2463 svc: svctest.MakeService("foo", 2464 svctest.SetHeadless, 2465 svctest.SetSelector(nil), 2466 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 2467 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 2468 expectPolicy: api.IPFamilyPolicyPreferDualStack, 2469 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 2470 expectHeadless: true, 2471 }, { 2472 name: "HeadlessSelectorless_Policy:RequireDualStack_Families:unset", 2473 line: line(), 2474 svc: svctest.MakeService("foo", 2475 svctest.SetHeadless, 2476 svctest.SetSelector(nil), 2477 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack)), 2478 expectPolicy: api.IPFamilyPolicyRequireDualStack, 2479 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 2480 expectHeadless: true, 2481 }, { 2482 name: "HeadlessSelectorless_Policy:RequireDualStack_Families:v4", 2483 line: line(), 2484 svc: svctest.MakeService("foo", 2485 svctest.SetHeadless, 2486 svctest.SetSelector(nil), 2487 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 2488 svctest.SetIPFamilies(api.IPv4Protocol)), 2489 expectPolicy: api.IPFamilyPolicyRequireDualStack, 2490 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 2491 expectHeadless: true, 2492 }, { 2493 name: "HeadlessSelectorless_Policy:RequireDualStack_Families:v6", 2494 line: line(), 2495 svc: svctest.MakeService("foo", 2496 svctest.SetHeadless, 2497 svctest.SetSelector(nil), 2498 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 2499 svctest.SetIPFamilies(api.IPv6Protocol)), 2500 expectPolicy: api.IPFamilyPolicyRequireDualStack, 2501 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 2502 expectHeadless: true, 2503 }, { 2504 name: "HeadlessSelectorless_Policy:RequireDualStack_Families:v4v6", 2505 line: line(), 2506 svc: svctest.MakeService("foo", 2507 svctest.SetHeadless, 2508 svctest.SetSelector(nil), 2509 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 2510 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 2511 expectPolicy: api.IPFamilyPolicyRequireDualStack, 2512 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 2513 expectHeadless: true, 2514 }, { 2515 name: "HeadlessSelectorless_Policy:RequireDualStack_Families:v6v4", 2516 line: line(), 2517 svc: svctest.MakeService("foo", 2518 svctest.SetHeadless, 2519 svctest.SetSelector(nil), 2520 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 2521 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 2522 expectPolicy: api.IPFamilyPolicyRequireDualStack, 2523 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 2524 expectHeadless: true, 2525 }, 2526 }, 2527 }, { 2528 name: "singlestack:v6", 2529 clusterFamilies: []api.IPFamily{api.IPv6Protocol}, 2530 cases: []testCase{ 2531 //---------------------------------------- 2532 // singlestack:v6 ClusterIPs:unset 2533 //---------------------------------------- 2534 { 2535 name: "ClusterIPs:unset_Policy:unset_Families:unset", 2536 line: line(), 2537 svc: svctest.MakeService("foo"), 2538 expectPolicy: api.IPFamilyPolicySingleStack, 2539 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 2540 }, { 2541 name: "ClusterIPs:unset_Policy:unset_Families:v4", 2542 line: line(), 2543 svc: svctest.MakeService("foo", 2544 svctest.SetIPFamilies(api.IPv4Protocol)), 2545 expectError: true, 2546 }, { 2547 name: "ClusterIPs:unset_Policy:unset_Families:v6", 2548 line: line(), 2549 svc: svctest.MakeService("foo", 2550 svctest.SetIPFamilies(api.IPv6Protocol)), 2551 expectPolicy: api.IPFamilyPolicySingleStack, 2552 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 2553 }, { 2554 name: "ClusterIPs:unset_Policy:unset_Families:v4v6", 2555 line: line(), 2556 svc: svctest.MakeService("foo", 2557 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 2558 expectError: true, 2559 }, { 2560 name: "ClusterIPs:unset_Policy:unset_Families:v6v4", 2561 line: line(), 2562 svc: svctest.MakeService("foo", 2563 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 2564 expectError: true, 2565 }, { 2566 name: "ClusterIPs:unset_Policy:SingleStack_Families:unset", 2567 line: line(), 2568 svc: svctest.MakeService("foo", 2569 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack)), 2570 expectPolicy: api.IPFamilyPolicySingleStack, 2571 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 2572 }, { 2573 name: "ClusterIPs:unset_Policy:SingleStack_Families:v4", 2574 line: line(), 2575 svc: svctest.MakeService("foo", 2576 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 2577 svctest.SetIPFamilies(api.IPv4Protocol)), 2578 expectError: true, 2579 }, { 2580 name: "ClusterIPs:unset_Policy:SingleStack_Families:v6", 2581 line: line(), 2582 svc: svctest.MakeService("foo", 2583 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 2584 svctest.SetIPFamilies(api.IPv6Protocol)), 2585 expectPolicy: api.IPFamilyPolicySingleStack, 2586 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 2587 }, { 2588 name: "ClusterIPs:unset_Policy:SingleStack_Families:v4v6", 2589 line: line(), 2590 svc: svctest.MakeService("foo", 2591 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 2592 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 2593 expectError: true, 2594 }, { 2595 name: "ClusterIPs:unset_Policy:SingleStack_Families:v6v4", 2596 line: line(), 2597 svc: svctest.MakeService("foo", 2598 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 2599 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 2600 expectError: true, 2601 }, { 2602 name: "ClusterIPs:unset_Policy:PreferDualStack_Families:unset", 2603 line: line(), 2604 svc: svctest.MakeService("foo", 2605 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack)), 2606 expectPolicy: api.IPFamilyPolicyPreferDualStack, 2607 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 2608 }, { 2609 name: "ClusterIPs:unset_Policy:PreferDualStack_Families:v4", 2610 line: line(), 2611 svc: svctest.MakeService("foo", 2612 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 2613 svctest.SetIPFamilies(api.IPv4Protocol)), 2614 expectError: true, 2615 }, { 2616 name: "ClusterIPs:unset_Policy:PreferDualStack_Families:v6", 2617 line: line(), 2618 svc: svctest.MakeService("foo", 2619 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 2620 svctest.SetIPFamilies(api.IPv6Protocol)), 2621 expectPolicy: api.IPFamilyPolicyPreferDualStack, 2622 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 2623 }, { 2624 name: "ClusterIPs:unset_Policy:PreferDualStack_Families:v4v6", 2625 line: line(), 2626 svc: svctest.MakeService("foo", 2627 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 2628 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 2629 expectError: true, 2630 }, { 2631 name: "ClusterIPs:unset_Policy:PreferDualStack_Families:v6v4", 2632 line: line(), 2633 svc: svctest.MakeService("foo", 2634 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 2635 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 2636 expectError: true, 2637 }, { 2638 name: "ClusterIPs:unset_Policy:RequireDualStack_Families:unset", 2639 line: line(), 2640 svc: svctest.MakeService("foo", 2641 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack)), 2642 expectError: true, 2643 }, { 2644 name: "ClusterIPs:unset_Policy:RequireDualStack_Families:v4", 2645 line: line(), 2646 svc: svctest.MakeService("foo", 2647 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 2648 svctest.SetIPFamilies(api.IPv4Protocol)), 2649 expectError: true, 2650 }, { 2651 name: "ClusterIPs:unset_Policy:RequireDualStack_Families:v6", 2652 line: line(), 2653 svc: svctest.MakeService("foo", 2654 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 2655 svctest.SetIPFamilies(api.IPv6Protocol)), 2656 expectError: true, 2657 }, { 2658 name: "ClusterIPs:unset_Policy:RequireDualStack_Families:v4v6", 2659 line: line(), 2660 svc: svctest.MakeService("foo", 2661 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 2662 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 2663 expectError: true, 2664 }, { 2665 name: "ClusterIPs:unset_Policy:RequireDualStack_Families:v6v4", 2666 line: line(), 2667 svc: svctest.MakeService("foo", 2668 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 2669 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 2670 expectError: true, 2671 }, 2672 //---------------------------------------- 2673 // singlestack:v6 ClusterIPs:v6 2674 //---------------------------------------- 2675 { 2676 name: "ClusterIPs:v6_Policy:unset_Families:unset", 2677 line: line(), 2678 svc: svctest.MakeService("foo", 2679 svctest.SetClusterIPs("2000::1")), 2680 expectPolicy: api.IPFamilyPolicySingleStack, 2681 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 2682 }, { 2683 name: "ClusterIPs:v6_Policy:unset_Families:v4", 2684 line: line(), 2685 svc: svctest.MakeService("foo", 2686 svctest.SetClusterIPs("2000::1"), 2687 svctest.SetIPFamilies(api.IPv4Protocol)), 2688 expectError: true, 2689 }, { 2690 name: "ClusterIPs:v6_Policy:unset_Families:v6", 2691 line: line(), 2692 svc: svctest.MakeService("foo", 2693 svctest.SetClusterIPs("2000::1"), 2694 svctest.SetIPFamilies(api.IPv6Protocol)), 2695 expectPolicy: api.IPFamilyPolicySingleStack, 2696 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 2697 }, { 2698 name: "ClusterIPs:v6_Policy:unset_Families:v4v6", 2699 line: line(), 2700 svc: svctest.MakeService("foo", 2701 svctest.SetClusterIPs("2000::1"), 2702 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 2703 expectError: true, 2704 }, { 2705 name: "ClusterIPs:v6_Policy:unset_Families:v6v4", 2706 line: line(), 2707 svc: svctest.MakeService("foo", 2708 svctest.SetClusterIPs("2000::1"), 2709 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 2710 expectError: true, 2711 }, { 2712 name: "ClusterIPs:v6_Policy:SingleStack_Families:unset", 2713 line: line(), 2714 svc: svctest.MakeService("foo", 2715 svctest.SetClusterIPs("2000::1"), 2716 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack)), 2717 expectPolicy: api.IPFamilyPolicySingleStack, 2718 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 2719 }, { 2720 name: "ClusterIPs:v6_Policy:SingleStack_Families:v4", 2721 line: line(), 2722 svc: svctest.MakeService("foo", 2723 svctest.SetClusterIPs("2000::1"), 2724 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 2725 svctest.SetIPFamilies(api.IPv4Protocol)), 2726 expectError: true, 2727 }, { 2728 name: "ClusterIPs:v6_Policy:SingleStack_Families:v6", 2729 line: line(), 2730 svc: svctest.MakeService("foo", 2731 svctest.SetClusterIPs("2000::1"), 2732 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 2733 svctest.SetIPFamilies(api.IPv6Protocol)), 2734 expectPolicy: api.IPFamilyPolicySingleStack, 2735 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 2736 }, { 2737 name: "ClusterIPs:v6_Policy:SingleStack_Families:v4v6", 2738 line: line(), 2739 svc: svctest.MakeService("foo", 2740 svctest.SetClusterIPs("2000::1"), 2741 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 2742 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 2743 expectError: true, 2744 }, { 2745 name: "ClusterIPs:v6_Policy:SingleStack_Families:v6v4", 2746 line: line(), 2747 svc: svctest.MakeService("foo", 2748 svctest.SetClusterIPs("2000::1"), 2749 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 2750 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 2751 expectError: true, 2752 }, { 2753 name: "ClusterIPs:v6_Policy:PreferDualStack_Families:unset", 2754 line: line(), 2755 svc: svctest.MakeService("foo", 2756 svctest.SetClusterIPs("2000::1"), 2757 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack)), 2758 expectPolicy: api.IPFamilyPolicyPreferDualStack, 2759 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 2760 }, { 2761 name: "ClusterIPs:v6_Policy:PreferDualStack_Families:v4", 2762 line: line(), 2763 svc: svctest.MakeService("foo", 2764 svctest.SetClusterIPs("2000::1"), 2765 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 2766 svctest.SetIPFamilies(api.IPv4Protocol)), 2767 expectError: true, 2768 }, { 2769 name: "ClusterIPs:v6_Policy:PreferDualStack_Families:v6", 2770 line: line(), 2771 svc: svctest.MakeService("foo", 2772 svctest.SetClusterIPs("2000::1"), 2773 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 2774 svctest.SetIPFamilies(api.IPv6Protocol)), 2775 expectPolicy: api.IPFamilyPolicyPreferDualStack, 2776 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 2777 }, { 2778 name: "ClusterIPs:v6_Policy:PreferDualStack_Families:v4v6", 2779 line: line(), 2780 svc: svctest.MakeService("foo", 2781 svctest.SetClusterIPs("2000::1"), 2782 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 2783 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 2784 expectError: true, 2785 }, { 2786 name: "ClusterIPs:v6_Policy:PreferDualStack_Families:v6v4", 2787 line: line(), 2788 svc: svctest.MakeService("foo", 2789 svctest.SetClusterIPs("2000::1"), 2790 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 2791 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 2792 expectError: true, 2793 }, { 2794 name: "ClusterIPs:v6_Policy:RequireDualStack_Families:unset", 2795 line: line(), 2796 svc: svctest.MakeService("foo", 2797 svctest.SetClusterIPs("2000::1"), 2798 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack)), 2799 expectError: true, 2800 }, { 2801 name: "ClusterIPs:v6_Policy:RequireDualStack_Families:v4", 2802 line: line(), 2803 svc: svctest.MakeService("foo", 2804 svctest.SetClusterIPs("2000::1"), 2805 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 2806 svctest.SetIPFamilies(api.IPv4Protocol)), 2807 expectError: true, 2808 }, { 2809 name: "ClusterIPs:v6_Policy:RequireDualStack_Families:v6", 2810 line: line(), 2811 svc: svctest.MakeService("foo", 2812 svctest.SetClusterIPs("2000::1"), 2813 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 2814 svctest.SetIPFamilies(api.IPv6Protocol)), 2815 expectError: true, 2816 }, { 2817 name: "ClusterIPs:v6_Policy:RequireDualStack_Families:v4v6", 2818 line: line(), 2819 svc: svctest.MakeService("foo", 2820 svctest.SetClusterIPs("2000::1"), 2821 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 2822 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 2823 expectError: true, 2824 }, { 2825 name: "ClusterIPs:v6_Policy:RequireDualStack_Families:v6v4", 2826 line: line(), 2827 svc: svctest.MakeService("foo", 2828 svctest.SetClusterIPs("2000::1"), 2829 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 2830 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 2831 expectError: true, 2832 }, 2833 //---------------------------------------- 2834 // singlestack:v6 ClusterIPs:v4v6 2835 //---------------------------------------- 2836 { 2837 name: "ClusterIPs:v4v6_Policy:unset_Families:unset", 2838 line: line(), 2839 svc: svctest.MakeService("foo", 2840 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 2841 expectError: true, 2842 }, { 2843 name: "ClusterIPs:v4v6_Policy:unset_Families:v4", 2844 line: line(), 2845 svc: svctest.MakeService("foo", 2846 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 2847 svctest.SetIPFamilies(api.IPv4Protocol)), 2848 expectError: true, 2849 }, { 2850 name: "ClusterIPs:v4v6_Policy:unset_Families:v6", 2851 line: line(), 2852 svc: svctest.MakeService("foo", 2853 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 2854 svctest.SetIPFamilies(api.IPv6Protocol)), 2855 expectError: true, 2856 }, { 2857 name: "ClusterIPs:v4v6_Policy:unset_Families:v4v6", 2858 line: line(), 2859 svc: svctest.MakeService("foo", 2860 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 2861 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 2862 expectError: true, 2863 }, { 2864 name: "ClusterIPs:v4v6_Policy:unset_Families:v6v4", 2865 line: line(), 2866 svc: svctest.MakeService("foo", 2867 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 2868 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 2869 expectError: true, 2870 }, { 2871 name: "ClusterIPs:v4v6_Policy:SingleStack_Families:unset", 2872 line: line(), 2873 svc: svctest.MakeService("foo", 2874 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 2875 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack)), 2876 expectError: true, 2877 }, { 2878 name: "ClusterIPs:v4v6_Policy:SingleStack_Families:v4", 2879 line: line(), 2880 svc: svctest.MakeService("foo", 2881 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 2882 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 2883 svctest.SetIPFamilies(api.IPv4Protocol)), 2884 expectError: true, 2885 }, { 2886 name: "ClusterIPs:v4v6_Policy:SingleStack_Families:v6", 2887 line: line(), 2888 svc: svctest.MakeService("foo", 2889 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 2890 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 2891 svctest.SetIPFamilies(api.IPv6Protocol)), 2892 expectError: true, 2893 }, { 2894 name: "ClusterIPs:v4v6_Policy:SingleStack_Families:v4v6", 2895 line: line(), 2896 svc: svctest.MakeService("foo", 2897 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 2898 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 2899 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 2900 expectError: true, 2901 }, { 2902 name: "ClusterIPs:v4v6_Policy:SingleStack_Families:v6v4", 2903 line: line(), 2904 svc: svctest.MakeService("foo", 2905 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 2906 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 2907 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 2908 expectError: true, 2909 }, { 2910 name: "ClusterIPs:v4v6_Policy:PreferDualStack_Families:unset", 2911 line: line(), 2912 svc: svctest.MakeService("foo", 2913 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 2914 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack)), 2915 expectError: true, 2916 }, { 2917 name: "ClusterIPs:v4v6_Policy:PreferDualStack_Families:v4", 2918 line: line(), 2919 svc: svctest.MakeService("foo", 2920 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 2921 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 2922 svctest.SetIPFamilies(api.IPv4Protocol)), 2923 expectError: true, 2924 }, { 2925 name: "ClusterIPs:v4v6_Policy:PreferDualStack_Families:v6", 2926 line: line(), 2927 svc: svctest.MakeService("foo", 2928 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 2929 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 2930 svctest.SetIPFamilies(api.IPv6Protocol)), 2931 expectError: true, 2932 }, { 2933 name: "ClusterIPs:v4v6_Policy:PreferDualStack_Families:v4v6", 2934 line: line(), 2935 svc: svctest.MakeService("foo", 2936 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 2937 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 2938 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 2939 expectError: true, 2940 }, { 2941 name: "ClusterIPs:v4v6_Policy:PreferDualStack_Families:v6v4", 2942 line: line(), 2943 svc: svctest.MakeService("foo", 2944 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 2945 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 2946 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 2947 expectError: true, 2948 }, { 2949 name: "ClusterIPs:v4v6_Policy:RequireDualStack_Families:unset", 2950 line: line(), 2951 svc: svctest.MakeService("foo", 2952 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 2953 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack)), 2954 expectError: true, 2955 }, { 2956 name: "ClusterIPs:v4v6_Policy:RequireDualStack_Families:v4", 2957 line: line(), 2958 svc: svctest.MakeService("foo", 2959 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 2960 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 2961 svctest.SetIPFamilies(api.IPv4Protocol)), 2962 expectError: true, 2963 }, { 2964 name: "ClusterIPs:v4v6_Policy:RequireDualStack_Families:v6", 2965 line: line(), 2966 svc: svctest.MakeService("foo", 2967 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 2968 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 2969 svctest.SetIPFamilies(api.IPv6Protocol)), 2970 expectError: true, 2971 }, { 2972 name: "ClusterIPs:v4v6_Policy:RequireDualStack_Families:v4v6", 2973 line: line(), 2974 svc: svctest.MakeService("foo", 2975 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 2976 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 2977 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 2978 expectError: true, 2979 }, { 2980 name: "ClusterIPs:v4v6_Policy:RequireDualStack_Families:v6v4", 2981 line: line(), 2982 svc: svctest.MakeService("foo", 2983 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 2984 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 2985 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 2986 expectError: true, 2987 }, 2988 //---------------------------------------- 2989 // singlestack:v6 ClusterIPs:v6v4 2990 //---------------------------------------- 2991 { 2992 name: "ClusterIPs:v6v4_Policy:unset_Families:unset", 2993 line: line(), 2994 svc: svctest.MakeService("foo", 2995 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 2996 expectError: true, 2997 }, { 2998 name: "ClusterIPs:v6v4_Policy:unset_Families:v4", 2999 line: line(), 3000 svc: svctest.MakeService("foo", 3001 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 3002 svctest.SetIPFamilies(api.IPv4Protocol)), 3003 expectError: true, 3004 }, { 3005 name: "ClusterIPs:v6v4_Policy:unset_Families:v6", 3006 line: line(), 3007 svc: svctest.MakeService("foo", 3008 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 3009 svctest.SetIPFamilies(api.IPv6Protocol)), 3010 expectError: true, 3011 }, { 3012 name: "ClusterIPs:v6v4_Policy:unset_Families:v4v6", 3013 line: line(), 3014 svc: svctest.MakeService("foo", 3015 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 3016 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 3017 expectError: true, 3018 }, { 3019 name: "ClusterIPs:v6v4_Policy:unset_Families:v6v4", 3020 line: line(), 3021 svc: svctest.MakeService("foo", 3022 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 3023 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 3024 expectError: true, 3025 }, { 3026 name: "ClusterIPs:v6v4_Policy:SingleStack_Families:unset", 3027 line: line(), 3028 svc: svctest.MakeService("foo", 3029 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 3030 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack)), 3031 expectError: true, 3032 }, { 3033 name: "ClusterIPs:v6v4_Policy:SingleStack_Families:v4", 3034 line: line(), 3035 svc: svctest.MakeService("foo", 3036 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 3037 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 3038 svctest.SetIPFamilies(api.IPv4Protocol)), 3039 expectError: true, 3040 }, { 3041 name: "ClusterIPs:v6v4_Policy:SingleStack_Families:v6", 3042 line: line(), 3043 svc: svctest.MakeService("foo", 3044 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 3045 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 3046 svctest.SetIPFamilies(api.IPv6Protocol)), 3047 expectError: true, 3048 }, { 3049 name: "ClusterIPs:v6v4_Policy:SingleStack_Families:v4v6", 3050 line: line(), 3051 svc: svctest.MakeService("foo", 3052 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 3053 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 3054 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 3055 expectError: true, 3056 }, { 3057 name: "ClusterIPs:v6v4_Policy:SingleStack_Families:v6v4", 3058 line: line(), 3059 svc: svctest.MakeService("foo", 3060 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 3061 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 3062 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 3063 expectError: true, 3064 }, { 3065 name: "ClusterIPs:v6v4_Policy:PreferDualStack_Families:unset", 3066 line: line(), 3067 svc: svctest.MakeService("foo", 3068 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 3069 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack)), 3070 expectError: true, 3071 }, { 3072 name: "ClusterIPs:v6v4_Policy:PreferDualStack_Families:v4", 3073 line: line(), 3074 svc: svctest.MakeService("foo", 3075 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 3076 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 3077 svctest.SetIPFamilies(api.IPv4Protocol)), 3078 expectError: true, 3079 }, { 3080 name: "ClusterIPs:v6v4_Policy:PreferDualStack_Families:v6", 3081 line: line(), 3082 svc: svctest.MakeService("foo", 3083 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 3084 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 3085 svctest.SetIPFamilies(api.IPv6Protocol)), 3086 expectError: true, 3087 }, { 3088 name: "ClusterIPs:v6v4_Policy:PreferDualStack_Families:v4v6", 3089 line: line(), 3090 svc: svctest.MakeService("foo", 3091 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 3092 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 3093 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 3094 expectError: true, 3095 }, { 3096 name: "ClusterIPs:v6v4_Policy:PreferDualStack_Families:v6v4", 3097 line: line(), 3098 svc: svctest.MakeService("foo", 3099 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 3100 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 3101 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 3102 expectError: true, 3103 }, { 3104 name: "ClusterIPs:v6v4_Policy:RequireDualStack_Families:unset", 3105 line: line(), 3106 svc: svctest.MakeService("foo", 3107 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 3108 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack)), 3109 expectError: true, 3110 }, { 3111 name: "ClusterIPs:v6v4_Policy:RequireDualStack_Families:v4", 3112 line: line(), 3113 svc: svctest.MakeService("foo", 3114 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 3115 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 3116 svctest.SetIPFamilies(api.IPv4Protocol)), 3117 expectError: true, 3118 }, { 3119 name: "ClusterIPs:v6v4_Policy:RequireDualStack_Families:v6", 3120 line: line(), 3121 svc: svctest.MakeService("foo", 3122 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 3123 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 3124 svctest.SetIPFamilies(api.IPv6Protocol)), 3125 expectError: true, 3126 }, { 3127 name: "ClusterIPs:v6v4_Policy:RequireDualStack_Families:v4v6", 3128 line: line(), 3129 svc: svctest.MakeService("foo", 3130 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 3131 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 3132 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 3133 expectError: true, 3134 }, { 3135 name: "ClusterIPs:v6v4_Policy:RequireDualStack_Families:v6v4", 3136 line: line(), 3137 svc: svctest.MakeService("foo", 3138 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 3139 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 3140 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 3141 expectError: true, 3142 }, 3143 //---------------------------------------- 3144 // singlestack:v6 Headless 3145 //---------------------------------------- 3146 { 3147 name: "Headless_Policy:unset_Families:unset", 3148 line: line(), 3149 svc: svctest.MakeService("foo", 3150 svctest.SetHeadless), 3151 expectPolicy: api.IPFamilyPolicySingleStack, 3152 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 3153 expectHeadless: true, 3154 }, { 3155 name: "Headless_Policy:unset_Families:v4", 3156 line: line(), 3157 svc: svctest.MakeService("foo", 3158 svctest.SetHeadless, 3159 svctest.SetIPFamilies(api.IPv4Protocol)), 3160 expectError: true, 3161 }, { 3162 name: "Headless_Policy:unset_Families:v6", 3163 line: line(), 3164 svc: svctest.MakeService("foo", 3165 svctest.SetHeadless, 3166 svctest.SetIPFamilies(api.IPv6Protocol)), 3167 expectPolicy: api.IPFamilyPolicySingleStack, 3168 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 3169 expectHeadless: true, 3170 }, { 3171 name: "Headless_Policy:unset_Families:v4v6", 3172 line: line(), 3173 svc: svctest.MakeService("foo", 3174 svctest.SetHeadless, 3175 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 3176 expectError: true, 3177 }, { 3178 name: "Headless_Policy:unset_Families:v6v4", 3179 line: line(), 3180 svc: svctest.MakeService("foo", 3181 svctest.SetHeadless, 3182 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 3183 expectError: true, 3184 }, { 3185 name: "Headless_Policy:SingleStack_Families:unset", 3186 line: line(), 3187 svc: svctest.MakeService("foo", 3188 svctest.SetHeadless, 3189 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack)), 3190 expectPolicy: api.IPFamilyPolicySingleStack, 3191 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 3192 expectHeadless: true, 3193 }, { 3194 name: "Headless_Policy:SingleStack_Families:v4", 3195 line: line(), 3196 svc: svctest.MakeService("foo", 3197 svctest.SetHeadless, 3198 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 3199 svctest.SetIPFamilies(api.IPv4Protocol)), 3200 expectError: true, 3201 }, { 3202 name: "Headless_Policy:SingleStack_Families:v6", 3203 line: line(), 3204 svc: svctest.MakeService("foo", 3205 svctest.SetHeadless, 3206 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 3207 svctest.SetIPFamilies(api.IPv6Protocol)), 3208 expectPolicy: api.IPFamilyPolicySingleStack, 3209 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 3210 expectHeadless: true, 3211 }, { 3212 name: "Headless_Policy:SingleStack_Families:v4v6", 3213 line: line(), 3214 svc: svctest.MakeService("foo", 3215 svctest.SetHeadless, 3216 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 3217 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 3218 expectError: true, 3219 }, { 3220 name: "Headless_Policy:SingleStack_Families:v6v4", 3221 line: line(), 3222 svc: svctest.MakeService("foo", 3223 svctest.SetHeadless, 3224 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 3225 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 3226 expectError: true, 3227 }, { 3228 name: "Headless_Policy:PreferDualStack_Families:unset", 3229 line: line(), 3230 svc: svctest.MakeService("foo", 3231 svctest.SetHeadless, 3232 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack)), 3233 expectPolicy: api.IPFamilyPolicyPreferDualStack, 3234 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 3235 expectHeadless: true, 3236 }, { 3237 name: "Headless_Policy:PreferDualStack_Families:v4", 3238 line: line(), 3239 svc: svctest.MakeService("foo", 3240 svctest.SetHeadless, 3241 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 3242 svctest.SetIPFamilies(api.IPv4Protocol)), 3243 expectError: true, 3244 }, { 3245 name: "Headless_Policy:PreferDualStack_Families:v6", 3246 line: line(), 3247 svc: svctest.MakeService("foo", 3248 svctest.SetHeadless, 3249 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 3250 svctest.SetIPFamilies(api.IPv6Protocol)), 3251 expectPolicy: api.IPFamilyPolicyPreferDualStack, 3252 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 3253 expectHeadless: true, 3254 }, { 3255 name: "Headless_Policy:PreferDualStack_Families:v4v6", 3256 line: line(), 3257 svc: svctest.MakeService("foo", 3258 svctest.SetHeadless, 3259 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 3260 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 3261 expectError: true, 3262 }, { 3263 name: "Headless_Policy:PreferDualStack_Families:v6v4", 3264 line: line(), 3265 svc: svctest.MakeService("foo", 3266 svctest.SetHeadless, 3267 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 3268 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 3269 expectError: true, 3270 }, { 3271 name: "Headless_Policy:RequireDualStack_Families:unset", 3272 line: line(), 3273 svc: svctest.MakeService("foo", 3274 svctest.SetHeadless, 3275 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack)), 3276 expectError: true, 3277 }, { 3278 name: "Headless_Policy:RequireDualStack_Families:v4", 3279 line: line(), 3280 svc: svctest.MakeService("foo", 3281 svctest.SetHeadless, 3282 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 3283 svctest.SetIPFamilies(api.IPv4Protocol)), 3284 expectError: true, 3285 }, { 3286 name: "Headless_Policy:RequireDualStack_Families:v6", 3287 line: line(), 3288 svc: svctest.MakeService("foo", 3289 svctest.SetHeadless, 3290 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 3291 svctest.SetIPFamilies(api.IPv6Protocol)), 3292 expectError: true, 3293 }, { 3294 name: "Headless_Policy:RequireDualStack_Families:v4v6", 3295 line: line(), 3296 svc: svctest.MakeService("foo", 3297 svctest.SetHeadless, 3298 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 3299 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 3300 expectError: true, 3301 }, { 3302 name: "Headless_Policy:RequireDualStack_Families:v6v4", 3303 line: line(), 3304 svc: svctest.MakeService("foo", 3305 svctest.SetHeadless, 3306 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 3307 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 3308 expectError: true, 3309 }, 3310 //---------------------------------------- 3311 // singlestack:v6 HeadlessSelectorless 3312 //---------------------------------------- 3313 { 3314 name: "HeadlessSelectorless_Policy:unset_Families:unset", 3315 line: line(), 3316 svc: svctest.MakeService("foo", 3317 svctest.SetHeadless, 3318 svctest.SetSelector(nil)), 3319 expectPolicy: api.IPFamilyPolicyRequireDualStack, 3320 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 3321 expectHeadless: true, 3322 }, { 3323 name: "HeadlessSelectorless_Policy:unset_Families:v4", 3324 line: line(), 3325 svc: svctest.MakeService("foo", 3326 svctest.SetHeadless, 3327 svctest.SetSelector(nil), 3328 svctest.SetIPFamilies(api.IPv4Protocol)), 3329 expectPolicy: api.IPFamilyPolicyRequireDualStack, 3330 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 3331 expectHeadless: true, 3332 }, { 3333 name: "HeadlessSelectorless_Policy:unset_Families:v6", 3334 line: line(), 3335 svc: svctest.MakeService("foo", 3336 svctest.SetHeadless, 3337 svctest.SetSelector(nil), 3338 svctest.SetIPFamilies(api.IPv6Protocol)), 3339 expectPolicy: api.IPFamilyPolicyRequireDualStack, 3340 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 3341 expectHeadless: true, 3342 }, { 3343 name: "HeadlessSelectorless_Policy:unset_Families:v4v6", 3344 line: line(), 3345 svc: svctest.MakeService("foo", 3346 svctest.SetHeadless, 3347 svctest.SetSelector(nil), 3348 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 3349 expectPolicy: api.IPFamilyPolicyRequireDualStack, 3350 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 3351 expectHeadless: true, 3352 }, { 3353 name: "HeadlessSelectorless_Policy:unset_Families:v6v4", 3354 line: line(), 3355 svc: svctest.MakeService("foo", 3356 svctest.SetHeadless, 3357 svctest.SetSelector(nil), 3358 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 3359 expectPolicy: api.IPFamilyPolicyRequireDualStack, 3360 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 3361 expectHeadless: true, 3362 }, { 3363 name: "HeadlessSelectorless_Policy:SingleStack_Families:unset", 3364 line: line(), 3365 svc: svctest.MakeService("foo", 3366 svctest.SetHeadless, 3367 svctest.SetSelector(nil), 3368 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack)), 3369 expectPolicy: api.IPFamilyPolicySingleStack, 3370 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 3371 expectHeadless: true, 3372 }, { 3373 name: "HeadlessSelectorless_Policy:SingleStack_Families:v4", 3374 line: line(), 3375 svc: svctest.MakeService("foo", 3376 svctest.SetHeadless, 3377 svctest.SetSelector(nil), 3378 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 3379 svctest.SetIPFamilies(api.IPv4Protocol)), 3380 expectPolicy: api.IPFamilyPolicySingleStack, 3381 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 3382 expectHeadless: true, 3383 }, { 3384 name: "HeadlessSelectorless_Policy:SingleStack_Families:v6", 3385 line: line(), 3386 svc: svctest.MakeService("foo", 3387 svctest.SetHeadless, 3388 svctest.SetSelector(nil), 3389 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 3390 svctest.SetIPFamilies(api.IPv6Protocol)), 3391 expectPolicy: api.IPFamilyPolicySingleStack, 3392 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 3393 expectHeadless: true, 3394 }, { 3395 name: "HeadlessSelectorless_Policy:SingleStack_Families:v4v6", 3396 line: line(), 3397 svc: svctest.MakeService("foo", 3398 svctest.SetHeadless, 3399 svctest.SetSelector(nil), 3400 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 3401 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 3402 expectError: true, 3403 }, { 3404 name: "HeadlessSelectorless_Policy:SingleStack_Families:v6v4", 3405 line: line(), 3406 svc: svctest.MakeService("foo", 3407 svctest.SetHeadless, 3408 svctest.SetSelector(nil), 3409 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 3410 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 3411 expectError: true, 3412 }, { 3413 name: "HeadlessSelectorless_Policy:PreferDualStack_Families:unset", 3414 line: line(), 3415 svc: svctest.MakeService("foo", 3416 svctest.SetHeadless, 3417 svctest.SetSelector(nil), 3418 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack)), 3419 expectPolicy: api.IPFamilyPolicyPreferDualStack, 3420 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 3421 expectHeadless: true, 3422 }, { 3423 name: "HeadlessSelectorless_Policy:PreferDualStack_Families:v4", 3424 line: line(), 3425 svc: svctest.MakeService("foo", 3426 svctest.SetHeadless, 3427 svctest.SetSelector(nil), 3428 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 3429 svctest.SetIPFamilies(api.IPv4Protocol)), 3430 expectPolicy: api.IPFamilyPolicyPreferDualStack, 3431 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 3432 expectHeadless: true, 3433 }, { 3434 name: "HeadlessSelectorless_Policy:PreferDualStack_Families:v6", 3435 line: line(), 3436 svc: svctest.MakeService("foo", 3437 svctest.SetHeadless, 3438 svctest.SetSelector(nil), 3439 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 3440 svctest.SetIPFamilies(api.IPv6Protocol)), 3441 expectPolicy: api.IPFamilyPolicyPreferDualStack, 3442 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 3443 expectHeadless: true, 3444 }, { 3445 name: "HeadlessSelectorless_Policy:PreferDualStack_Families:v4v6", 3446 line: line(), 3447 svc: svctest.MakeService("foo", 3448 svctest.SetHeadless, 3449 svctest.SetSelector(nil), 3450 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 3451 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 3452 expectPolicy: api.IPFamilyPolicyPreferDualStack, 3453 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 3454 expectHeadless: true, 3455 }, { 3456 name: "HeadlessSelectorless_Policy:PreferDualStack_Families:v6v4", 3457 line: line(), 3458 svc: svctest.MakeService("foo", 3459 svctest.SetHeadless, 3460 svctest.SetSelector(nil), 3461 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 3462 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 3463 expectPolicy: api.IPFamilyPolicyPreferDualStack, 3464 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 3465 expectHeadless: true, 3466 }, { 3467 name: "HeadlessSelectorless_Policy:RequireDualStack_Families:unset", 3468 line: line(), 3469 svc: svctest.MakeService("foo", 3470 svctest.SetHeadless, 3471 svctest.SetSelector(nil), 3472 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack)), 3473 expectPolicy: api.IPFamilyPolicyRequireDualStack, 3474 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 3475 expectHeadless: true, 3476 }, { 3477 name: "HeadlessSelectorless_Policy:RequireDualStack_Families:v4", 3478 line: line(), 3479 svc: svctest.MakeService("foo", 3480 svctest.SetHeadless, 3481 svctest.SetSelector(nil), 3482 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 3483 svctest.SetIPFamilies(api.IPv4Protocol)), 3484 expectPolicy: api.IPFamilyPolicyRequireDualStack, 3485 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 3486 expectHeadless: true, 3487 }, { 3488 name: "HeadlessSelectorless_Policy:RequireDualStack_Families:v6", 3489 line: line(), 3490 svc: svctest.MakeService("foo", 3491 svctest.SetHeadless, 3492 svctest.SetSelector(nil), 3493 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 3494 svctest.SetIPFamilies(api.IPv6Protocol)), 3495 expectPolicy: api.IPFamilyPolicyRequireDualStack, 3496 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 3497 expectHeadless: true, 3498 }, { 3499 name: "HeadlessSelectorless_Policy:RequireDualStack_Families:v4v6", 3500 line: line(), 3501 svc: svctest.MakeService("foo", 3502 svctest.SetHeadless, 3503 svctest.SetSelector(nil), 3504 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 3505 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 3506 expectPolicy: api.IPFamilyPolicyRequireDualStack, 3507 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 3508 expectHeadless: true, 3509 }, { 3510 name: "HeadlessSelectorless_Policy:RequireDualStack_Families:v6v4", 3511 line: line(), 3512 svc: svctest.MakeService("foo", 3513 svctest.SetHeadless, 3514 svctest.SetSelector(nil), 3515 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 3516 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 3517 expectPolicy: api.IPFamilyPolicyRequireDualStack, 3518 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 3519 expectHeadless: true, 3520 }, 3521 }, 3522 }, { 3523 name: "dualstack:v4v6", 3524 clusterFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 3525 cases: []testCase{ 3526 //---------------------------------------- 3527 // dualstack:v4v6 ClusterIPs:unset 3528 //---------------------------------------- 3529 { 3530 name: "ClusterIPs:unset_Policy:unset_Families:unset", 3531 line: line(), 3532 svc: svctest.MakeService("foo"), 3533 expectPolicy: api.IPFamilyPolicySingleStack, 3534 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 3535 }, { 3536 name: "ClusterIPs:unset_Policy:unset_Families:v4", 3537 line: line(), 3538 svc: svctest.MakeService("foo", 3539 svctest.SetIPFamilies(api.IPv4Protocol)), 3540 expectPolicy: api.IPFamilyPolicySingleStack, 3541 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 3542 }, { 3543 name: "ClusterIPs:unset_Policy:unset_Families:v6", 3544 line: line(), 3545 svc: svctest.MakeService("foo", 3546 svctest.SetIPFamilies(api.IPv6Protocol)), 3547 expectPolicy: api.IPFamilyPolicySingleStack, 3548 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 3549 }, { 3550 name: "ClusterIPs:unset_Policy:unset_Families:v4v6", 3551 line: line(), 3552 svc: svctest.MakeService("foo", 3553 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 3554 expectError: true, 3555 }, { 3556 name: "ClusterIPs:unset_Policy:unset_Families:v6v4", 3557 line: line(), 3558 svc: svctest.MakeService("foo", 3559 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 3560 expectError: true, 3561 }, { 3562 name: "ClusterIPs:unset_Policy:SingleStack_Families:unset", 3563 line: line(), 3564 svc: svctest.MakeService("foo", 3565 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack)), 3566 expectPolicy: api.IPFamilyPolicySingleStack, 3567 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 3568 }, { 3569 name: "ClusterIPs:unset_Policy:SingleStack_Families:v4", 3570 line: line(), 3571 svc: svctest.MakeService("foo", 3572 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 3573 svctest.SetIPFamilies(api.IPv4Protocol)), 3574 expectPolicy: api.IPFamilyPolicySingleStack, 3575 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 3576 }, { 3577 name: "ClusterIPs:unset_Policy:SingleStack_Families:v6", 3578 line: line(), 3579 svc: svctest.MakeService("foo", 3580 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 3581 svctest.SetIPFamilies(api.IPv6Protocol)), 3582 expectPolicy: api.IPFamilyPolicySingleStack, 3583 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 3584 }, { 3585 name: "ClusterIPs:unset_Policy:SingleStack_Families:v4v6", 3586 line: line(), 3587 svc: svctest.MakeService("foo", 3588 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 3589 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 3590 expectError: true, 3591 }, { 3592 name: "ClusterIPs:unset_Policy:SingleStack_Families:v6v4", 3593 line: line(), 3594 svc: svctest.MakeService("foo", 3595 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 3596 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 3597 expectError: true, 3598 }, { 3599 name: "ClusterIPs:unset_Policy:PreferDualStack_Families:unset", 3600 line: line(), 3601 svc: svctest.MakeService("foo", 3602 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack)), 3603 expectPolicy: api.IPFamilyPolicyPreferDualStack, 3604 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 3605 }, { 3606 name: "ClusterIPs:unset_Policy:PreferDualStack_Families:v4", 3607 line: line(), 3608 svc: svctest.MakeService("foo", 3609 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 3610 svctest.SetIPFamilies(api.IPv4Protocol)), 3611 expectPolicy: api.IPFamilyPolicyPreferDualStack, 3612 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 3613 }, { 3614 name: "ClusterIPs:unset_Policy:PreferDualStack_Families:v6", 3615 line: line(), 3616 svc: svctest.MakeService("foo", 3617 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 3618 svctest.SetIPFamilies(api.IPv6Protocol)), 3619 expectPolicy: api.IPFamilyPolicyPreferDualStack, 3620 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 3621 }, { 3622 name: "ClusterIPs:unset_Policy:PreferDualStack_Families:v4v6", 3623 line: line(), 3624 svc: svctest.MakeService("foo", 3625 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 3626 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 3627 expectPolicy: api.IPFamilyPolicyPreferDualStack, 3628 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 3629 }, { 3630 name: "ClusterIPs:unset_Policy:PreferDualStack_Families:v6v4", 3631 line: line(), 3632 svc: svctest.MakeService("foo", 3633 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 3634 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 3635 expectPolicy: api.IPFamilyPolicyPreferDualStack, 3636 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 3637 }, { 3638 name: "ClusterIPs:unset_Policy:RequireDualStack_Families:unset", 3639 line: line(), 3640 svc: svctest.MakeService("foo", 3641 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack)), 3642 expectPolicy: api.IPFamilyPolicyRequireDualStack, 3643 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 3644 }, { 3645 name: "ClusterIPs:unset_Policy:RequireDualStack_Families:v4", 3646 line: line(), 3647 svc: svctest.MakeService("foo", 3648 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 3649 svctest.SetIPFamilies(api.IPv4Protocol)), 3650 expectPolicy: api.IPFamilyPolicyRequireDualStack, 3651 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 3652 }, { 3653 name: "ClusterIPs:unset_Policy:RequireDualStack_Families:v6", 3654 line: line(), 3655 svc: svctest.MakeService("foo", 3656 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 3657 svctest.SetIPFamilies(api.IPv6Protocol)), 3658 expectPolicy: api.IPFamilyPolicyRequireDualStack, 3659 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 3660 }, { 3661 name: "ClusterIPs:unset_Policy:RequireDualStack_Families:v4v6", 3662 line: line(), 3663 svc: svctest.MakeService("foo", 3664 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 3665 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 3666 expectPolicy: api.IPFamilyPolicyRequireDualStack, 3667 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 3668 }, { 3669 name: "ClusterIPs:unset_Policy:RequireDualStack_Families:v6v4", 3670 line: line(), 3671 svc: svctest.MakeService("foo", 3672 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 3673 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 3674 expectPolicy: api.IPFamilyPolicyRequireDualStack, 3675 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 3676 }, 3677 //---------------------------------------- 3678 // dualstack:v4v6 ClusterIPs:v4 3679 //---------------------------------------- 3680 { 3681 name: "ClusterIPs:v4_Policy:unset_Families:unset", 3682 line: line(), 3683 svc: svctest.MakeService("foo", 3684 svctest.SetClusterIPs("10.0.0.1")), 3685 expectPolicy: api.IPFamilyPolicySingleStack, 3686 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 3687 }, { 3688 name: "ClusterIPs:v4_Policy:unset_Families:v4", 3689 line: line(), 3690 svc: svctest.MakeService("foo", 3691 svctest.SetClusterIPs("10.0.0.1"), 3692 svctest.SetIPFamilies(api.IPv4Protocol)), 3693 expectPolicy: api.IPFamilyPolicySingleStack, 3694 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 3695 }, { 3696 name: "ClusterIPs:v4_Policy:unset_Families:v6", 3697 line: line(), 3698 svc: svctest.MakeService("foo", 3699 svctest.SetClusterIPs("10.0.0.1"), 3700 svctest.SetIPFamilies(api.IPv6Protocol)), 3701 expectError: true, 3702 }, { 3703 name: "ClusterIPs:v4_Policy:unset_Families:v4v6", 3704 line: line(), 3705 svc: svctest.MakeService("foo", 3706 svctest.SetClusterIPs("10.0.0.1"), 3707 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 3708 expectError: true, 3709 }, { 3710 name: "ClusterIPs:v4_Policy:unset_Families:v6v4", 3711 line: line(), 3712 svc: svctest.MakeService("foo", 3713 svctest.SetClusterIPs("10.0.0.1"), 3714 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 3715 expectError: true, 3716 }, { 3717 name: "ClusterIPs:v4_Policy:SingleStack_Families:unset", 3718 line: line(), 3719 svc: svctest.MakeService("foo", 3720 svctest.SetClusterIPs("10.0.0.1"), 3721 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack)), 3722 expectPolicy: api.IPFamilyPolicySingleStack, 3723 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 3724 }, { 3725 name: "ClusterIPs:v4_Policy:SingleStack_Families:v4", 3726 line: line(), 3727 svc: svctest.MakeService("foo", 3728 svctest.SetClusterIPs("10.0.0.1"), 3729 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 3730 svctest.SetIPFamilies(api.IPv4Protocol)), 3731 expectPolicy: api.IPFamilyPolicySingleStack, 3732 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 3733 }, { 3734 name: "ClusterIPs:v4_Policy:SingleStack_Families:v6", 3735 line: line(), 3736 svc: svctest.MakeService("foo", 3737 svctest.SetClusterIPs("10.0.0.1"), 3738 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 3739 svctest.SetIPFamilies(api.IPv6Protocol)), 3740 expectError: true, 3741 }, { 3742 name: "ClusterIPs:v4_Policy:SingleStack_Families:v4v6", 3743 line: line(), 3744 svc: svctest.MakeService("foo", 3745 svctest.SetClusterIPs("10.0.0.1"), 3746 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 3747 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 3748 expectError: true, 3749 }, { 3750 name: "ClusterIPs:v4_Policy:SingleStack_Families:v6v4", 3751 line: line(), 3752 svc: svctest.MakeService("foo", 3753 svctest.SetClusterIPs("10.0.0.1"), 3754 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 3755 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 3756 expectError: true, 3757 }, { 3758 name: "ClusterIPs:v4_Policy:PreferDualStack_Families:unset", 3759 line: line(), 3760 svc: svctest.MakeService("foo", 3761 svctest.SetClusterIPs("10.0.0.1"), 3762 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack)), 3763 expectPolicy: api.IPFamilyPolicyPreferDualStack, 3764 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 3765 }, { 3766 name: "ClusterIPs:v4_Policy:PreferDualStack_Families:v4", 3767 line: line(), 3768 svc: svctest.MakeService("foo", 3769 svctest.SetClusterIPs("10.0.0.1"), 3770 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 3771 svctest.SetIPFamilies(api.IPv4Protocol)), 3772 expectPolicy: api.IPFamilyPolicyPreferDualStack, 3773 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 3774 }, { 3775 name: "ClusterIPs:v4_Policy:PreferDualStack_Families:v6", 3776 line: line(), 3777 svc: svctest.MakeService("foo", 3778 svctest.SetClusterIPs("10.0.0.1"), 3779 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 3780 svctest.SetIPFamilies(api.IPv6Protocol)), 3781 expectError: true, 3782 }, { 3783 name: "ClusterIPs:v4_Policy:PreferDualStack_Families:v4v6", 3784 line: line(), 3785 svc: svctest.MakeService("foo", 3786 svctest.SetClusterIPs("10.0.0.1"), 3787 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 3788 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 3789 expectPolicy: api.IPFamilyPolicyPreferDualStack, 3790 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 3791 }, { 3792 name: "ClusterIPs:v4_Policy:PreferDualStack_Families:v6v4", 3793 line: line(), 3794 svc: svctest.MakeService("foo", 3795 svctest.SetClusterIPs("10.0.0.1"), 3796 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 3797 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 3798 expectError: true, 3799 }, { 3800 name: "ClusterIPs:v4_Policy:RequireDualStack_Families:unset", 3801 line: line(), 3802 svc: svctest.MakeService("foo", 3803 svctest.SetClusterIPs("10.0.0.1"), 3804 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack)), 3805 expectPolicy: api.IPFamilyPolicyRequireDualStack, 3806 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 3807 }, { 3808 name: "ClusterIPs:v4_Policy:RequireDualStack_Families:v4", 3809 line: line(), 3810 svc: svctest.MakeService("foo", 3811 svctest.SetClusterIPs("10.0.0.1"), 3812 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 3813 svctest.SetIPFamilies(api.IPv4Protocol)), 3814 expectPolicy: api.IPFamilyPolicyRequireDualStack, 3815 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 3816 }, { 3817 name: "ClusterIPs:v4_Policy:RequireDualStack_Families:v6", 3818 line: line(), 3819 svc: svctest.MakeService("foo", 3820 svctest.SetClusterIPs("10.0.0.1"), 3821 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 3822 svctest.SetIPFamilies(api.IPv6Protocol)), 3823 expectError: true, 3824 }, { 3825 name: "ClusterIPs:v4_Policy:RequireDualStack_Families:v4v6", 3826 line: line(), 3827 svc: svctest.MakeService("foo", 3828 svctest.SetClusterIPs("10.0.0.1"), 3829 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 3830 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 3831 expectPolicy: api.IPFamilyPolicyRequireDualStack, 3832 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 3833 }, { 3834 name: "ClusterIPs:v4_Policy:RequireDualStack_Families:v6v4", 3835 line: line(), 3836 svc: svctest.MakeService("foo", 3837 svctest.SetClusterIPs("10.0.0.1"), 3838 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 3839 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 3840 expectError: true, 3841 }, 3842 //---------------------------------------- 3843 // dualstack:v4v6 ClusterIPs:v6 3844 //---------------------------------------- 3845 { 3846 name: "ClusterIPs:v6_Policy:unset_Families:unset", 3847 line: line(), 3848 svc: svctest.MakeService("foo", 3849 svctest.SetClusterIPs("2000::1")), 3850 expectPolicy: api.IPFamilyPolicySingleStack, 3851 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 3852 }, { 3853 name: "ClusterIPs:v6_Policy:unset_Families:v4", 3854 line: line(), 3855 svc: svctest.MakeService("foo", 3856 svctest.SetClusterIPs("2000::1"), 3857 svctest.SetIPFamilies(api.IPv4Protocol)), 3858 expectError: true, 3859 }, { 3860 name: "ClusterIPs:v6_Policy:unset_Families:v6", 3861 line: line(), 3862 svc: svctest.MakeService("foo", 3863 svctest.SetClusterIPs("2000::1"), 3864 svctest.SetIPFamilies(api.IPv6Protocol)), 3865 expectPolicy: api.IPFamilyPolicySingleStack, 3866 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 3867 }, { 3868 name: "ClusterIPs:v6_Policy:unset_Families:v4v6", 3869 line: line(), 3870 svc: svctest.MakeService("foo", 3871 svctest.SetClusterIPs("2000::1"), 3872 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 3873 expectError: true, 3874 }, { 3875 name: "ClusterIPs:v6_Policy:unset_Families:v6v4", 3876 line: line(), 3877 svc: svctest.MakeService("foo", 3878 svctest.SetClusterIPs("2000::1"), 3879 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 3880 expectError: true, 3881 }, { 3882 name: "ClusterIPs:v6_Policy:SingleStack_Families:unset", 3883 line: line(), 3884 svc: svctest.MakeService("foo", 3885 svctest.SetClusterIPs("2000::1"), 3886 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack)), 3887 expectPolicy: api.IPFamilyPolicySingleStack, 3888 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 3889 }, { 3890 name: "ClusterIPs:v6_Policy:SingleStack_Families:v4", 3891 line: line(), 3892 svc: svctest.MakeService("foo", 3893 svctest.SetClusterIPs("2000::1"), 3894 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 3895 svctest.SetIPFamilies(api.IPv4Protocol)), 3896 expectError: true, 3897 }, { 3898 name: "ClusterIPs:v6_Policy:SingleStack_Families:v6", 3899 line: line(), 3900 svc: svctest.MakeService("foo", 3901 svctest.SetClusterIPs("2000::1"), 3902 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 3903 svctest.SetIPFamilies(api.IPv6Protocol)), 3904 expectPolicy: api.IPFamilyPolicySingleStack, 3905 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 3906 }, { 3907 name: "ClusterIPs:v6_Policy:SingleStack_Families:v4v6", 3908 line: line(), 3909 svc: svctest.MakeService("foo", 3910 svctest.SetClusterIPs("2000::1"), 3911 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 3912 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 3913 expectError: true, 3914 }, { 3915 name: "ClusterIPs:v6_Policy:SingleStack_Families:v6v4", 3916 line: line(), 3917 svc: svctest.MakeService("foo", 3918 svctest.SetClusterIPs("2000::1"), 3919 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 3920 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 3921 expectError: true, 3922 }, { 3923 name: "ClusterIPs:v6_Policy:PreferDualStack_Families:unset", 3924 line: line(), 3925 svc: svctest.MakeService("foo", 3926 svctest.SetClusterIPs("2000::1"), 3927 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack)), 3928 expectPolicy: api.IPFamilyPolicyPreferDualStack, 3929 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 3930 }, { 3931 name: "ClusterIPs:v6_Policy:PreferDualStack_Families:v4", 3932 line: line(), 3933 svc: svctest.MakeService("foo", 3934 svctest.SetClusterIPs("2000::1"), 3935 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 3936 svctest.SetIPFamilies(api.IPv4Protocol)), 3937 expectError: true, 3938 }, { 3939 name: "ClusterIPs:v6_Policy:PreferDualStack_Families:v6", 3940 line: line(), 3941 svc: svctest.MakeService("foo", 3942 svctest.SetClusterIPs("2000::1"), 3943 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 3944 svctest.SetIPFamilies(api.IPv6Protocol)), 3945 expectPolicy: api.IPFamilyPolicyPreferDualStack, 3946 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 3947 }, { 3948 name: "ClusterIPs:v6_Policy:PreferDualStack_Families:v4v6", 3949 line: line(), 3950 svc: svctest.MakeService("foo", 3951 svctest.SetClusterIPs("2000::1"), 3952 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 3953 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 3954 expectError: true, 3955 }, { 3956 name: "ClusterIPs:v6_Policy:PreferDualStack_Families:v6v4", 3957 line: line(), 3958 svc: svctest.MakeService("foo", 3959 svctest.SetClusterIPs("2000::1"), 3960 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 3961 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 3962 expectPolicy: api.IPFamilyPolicyPreferDualStack, 3963 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 3964 }, { 3965 name: "ClusterIPs:v6_Policy:RequireDualStack_Families:unset", 3966 line: line(), 3967 svc: svctest.MakeService("foo", 3968 svctest.SetClusterIPs("2000::1"), 3969 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack)), 3970 expectPolicy: api.IPFamilyPolicyRequireDualStack, 3971 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 3972 }, { 3973 name: "ClusterIPs:v6_Policy:RequireDualStack_Families:v4", 3974 line: line(), 3975 svc: svctest.MakeService("foo", 3976 svctest.SetClusterIPs("2000::1"), 3977 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 3978 svctest.SetIPFamilies(api.IPv4Protocol)), 3979 expectError: true, 3980 }, { 3981 name: "ClusterIPs:v6_Policy:RequireDualStack_Families:v6", 3982 line: line(), 3983 svc: svctest.MakeService("foo", 3984 svctest.SetClusterIPs("2000::1"), 3985 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 3986 svctest.SetIPFamilies(api.IPv6Protocol)), 3987 expectPolicy: api.IPFamilyPolicyRequireDualStack, 3988 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 3989 }, { 3990 name: "ClusterIPs:v6_Policy:RequireDualStack_Families:v4v6", 3991 line: line(), 3992 svc: svctest.MakeService("foo", 3993 svctest.SetClusterIPs("2000::1"), 3994 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 3995 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 3996 expectError: true, 3997 }, { 3998 name: "ClusterIPs:v6_Policy:RequireDualStack_Families:v6v4", 3999 line: line(), 4000 svc: svctest.MakeService("foo", 4001 svctest.SetClusterIPs("2000::1"), 4002 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 4003 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 4004 expectPolicy: api.IPFamilyPolicyRequireDualStack, 4005 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 4006 }, 4007 //---------------------------------------- 4008 // dualstack:v4v6 ClusterIPs:v4v6 4009 //---------------------------------------- 4010 { 4011 name: "ClusterIPs:v4v6_Policy:unset_Families:unset", 4012 line: line(), 4013 svc: svctest.MakeService("foo", 4014 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 4015 expectError: true, 4016 }, { 4017 name: "ClusterIPs:v4v6_Policy:unset_Families:v4", 4018 line: line(), 4019 svc: svctest.MakeService("foo", 4020 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 4021 svctest.SetIPFamilies(api.IPv4Protocol)), 4022 expectError: true, 4023 }, { 4024 name: "ClusterIPs:v4v6_Policy:unset_Families:v6", 4025 line: line(), 4026 svc: svctest.MakeService("foo", 4027 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 4028 svctest.SetIPFamilies(api.IPv6Protocol)), 4029 expectError: true, 4030 }, { 4031 name: "ClusterIPs:v4v6_Policy:unset_Families:v4v6", 4032 line: line(), 4033 svc: svctest.MakeService("foo", 4034 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 4035 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 4036 expectError: true, 4037 }, { 4038 name: "ClusterIPs:v4v6_Policy:unset_Families:v6v4", 4039 line: line(), 4040 svc: svctest.MakeService("foo", 4041 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 4042 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 4043 expectError: true, 4044 }, { 4045 name: "ClusterIPs:v4v6_Policy:SingleStack_Families:unset", 4046 line: line(), 4047 svc: svctest.MakeService("foo", 4048 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 4049 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack)), 4050 expectError: true, 4051 }, { 4052 name: "ClusterIPs:v4v6_Policy:SingleStack_Families:v4", 4053 line: line(), 4054 svc: svctest.MakeService("foo", 4055 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 4056 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 4057 svctest.SetIPFamilies(api.IPv4Protocol)), 4058 expectError: true, 4059 }, { 4060 name: "ClusterIPs:v4v6_Policy:SingleStack_Families:v6", 4061 line: line(), 4062 svc: svctest.MakeService("foo", 4063 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 4064 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 4065 svctest.SetIPFamilies(api.IPv6Protocol)), 4066 expectError: true, 4067 }, { 4068 name: "ClusterIPs:v4v6_Policy:SingleStack_Families:v4v6", 4069 line: line(), 4070 svc: svctest.MakeService("foo", 4071 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 4072 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 4073 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 4074 expectError: true, 4075 }, { 4076 name: "ClusterIPs:v4v6_Policy:SingleStack_Families:v6v4", 4077 line: line(), 4078 svc: svctest.MakeService("foo", 4079 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 4080 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 4081 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 4082 expectError: true, 4083 }, { 4084 name: "ClusterIPs:v4v6_Policy:PreferDualStack_Families:unset", 4085 line: line(), 4086 svc: svctest.MakeService("foo", 4087 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 4088 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack)), 4089 expectPolicy: api.IPFamilyPolicyPreferDualStack, 4090 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 4091 }, { 4092 name: "ClusterIPs:v4v6_Policy:PreferDualStack_Families:v4", 4093 line: line(), 4094 svc: svctest.MakeService("foo", 4095 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 4096 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 4097 svctest.SetIPFamilies(api.IPv4Protocol)), 4098 expectPolicy: api.IPFamilyPolicyPreferDualStack, 4099 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 4100 }, { 4101 name: "ClusterIPs:v4v6_Policy:PreferDualStack_Families:v6", 4102 line: line(), 4103 svc: svctest.MakeService("foo", 4104 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 4105 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 4106 svctest.SetIPFamilies(api.IPv6Protocol)), 4107 expectError: true, 4108 }, { 4109 name: "ClusterIPs:v4v6_Policy:PreferDualStack_Families:v4v6", 4110 line: line(), 4111 svc: svctest.MakeService("foo", 4112 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 4113 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 4114 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 4115 expectPolicy: api.IPFamilyPolicyPreferDualStack, 4116 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 4117 }, { 4118 name: "ClusterIPs:v4v6_Policy:PreferDualStack_Families:v6v4", 4119 line: line(), 4120 svc: svctest.MakeService("foo", 4121 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 4122 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 4123 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 4124 expectError: true, 4125 }, { 4126 name: "ClusterIPs:v4v6_Policy:RequireDualStack_Families:unset", 4127 line: line(), 4128 svc: svctest.MakeService("foo", 4129 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 4130 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack)), 4131 expectPolicy: api.IPFamilyPolicyRequireDualStack, 4132 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 4133 }, { 4134 name: "ClusterIPs:v4v6_Policy:RequireDualStack_Families:v4", 4135 line: line(), 4136 svc: svctest.MakeService("foo", 4137 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 4138 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 4139 svctest.SetIPFamilies(api.IPv4Protocol)), 4140 expectPolicy: api.IPFamilyPolicyRequireDualStack, 4141 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 4142 }, { 4143 name: "ClusterIPs:v4v6_Policy:RequireDualStack_Families:v6", 4144 line: line(), 4145 svc: svctest.MakeService("foo", 4146 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 4147 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 4148 svctest.SetIPFamilies(api.IPv6Protocol)), 4149 expectError: true, 4150 }, { 4151 name: "ClusterIPs:v4v6_Policy:RequireDualStack_Families:v4v6", 4152 line: line(), 4153 svc: svctest.MakeService("foo", 4154 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 4155 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 4156 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 4157 expectPolicy: api.IPFamilyPolicyRequireDualStack, 4158 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 4159 }, { 4160 name: "ClusterIPs:v4v6_Policy:RequireDualStack_Families:v6v4", 4161 line: line(), 4162 svc: svctest.MakeService("foo", 4163 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 4164 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 4165 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 4166 expectError: true, 4167 }, 4168 //---------------------------------------- 4169 // dualstack:v4v6 ClusterIPs:v6v4 4170 //---------------------------------------- 4171 { 4172 name: "ClusterIPs:v6v4_Policy:unset_Families:unset", 4173 line: line(), 4174 svc: svctest.MakeService("foo", 4175 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 4176 expectError: true, 4177 }, { 4178 name: "ClusterIPs:v6v4_Policy:unset_Families:v4", 4179 line: line(), 4180 svc: svctest.MakeService("foo", 4181 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 4182 svctest.SetIPFamilies(api.IPv4Protocol)), 4183 expectError: true, 4184 }, { 4185 name: "ClusterIPs:v6v4_Policy:unset_Families:v6", 4186 line: line(), 4187 svc: svctest.MakeService("foo", 4188 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 4189 svctest.SetIPFamilies(api.IPv6Protocol)), 4190 expectError: true, 4191 }, { 4192 name: "ClusterIPs:v6v4_Policy:unset_Families:v4v6", 4193 line: line(), 4194 svc: svctest.MakeService("foo", 4195 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 4196 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 4197 expectError: true, 4198 }, { 4199 name: "ClusterIPs:v6v4_Policy:unset_Families:v6v4", 4200 line: line(), 4201 svc: svctest.MakeService("foo", 4202 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 4203 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 4204 expectError: true, 4205 }, { 4206 name: "ClusterIPs:v6v4_Policy:SingleStack_Families:unset", 4207 line: line(), 4208 svc: svctest.MakeService("foo", 4209 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 4210 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack)), 4211 expectError: true, 4212 }, { 4213 name: "ClusterIPs:v6v4_Policy:SingleStack_Families:v4", 4214 line: line(), 4215 svc: svctest.MakeService("foo", 4216 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 4217 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 4218 svctest.SetIPFamilies(api.IPv4Protocol)), 4219 expectError: true, 4220 }, { 4221 name: "ClusterIPs:v6v4_Policy:SingleStack_Families:v6", 4222 line: line(), 4223 svc: svctest.MakeService("foo", 4224 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 4225 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 4226 svctest.SetIPFamilies(api.IPv6Protocol)), 4227 expectError: true, 4228 }, { 4229 name: "ClusterIPs:v6v4_Policy:SingleStack_Families:v4v6", 4230 line: line(), 4231 svc: svctest.MakeService("foo", 4232 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 4233 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 4234 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 4235 expectError: true, 4236 }, { 4237 name: "ClusterIPs:v6v4_Policy:SingleStack_Families:v6v4", 4238 line: line(), 4239 svc: svctest.MakeService("foo", 4240 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 4241 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 4242 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 4243 expectError: true, 4244 }, { 4245 name: "ClusterIPs:v6v4_Policy:PreferDualStack_Families:unset", 4246 line: line(), 4247 svc: svctest.MakeService("foo", 4248 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 4249 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack)), 4250 expectPolicy: api.IPFamilyPolicyPreferDualStack, 4251 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 4252 }, { 4253 name: "ClusterIPs:v6v4_Policy:PreferDualStack_Families:v4", 4254 line: line(), 4255 svc: svctest.MakeService("foo", 4256 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 4257 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 4258 svctest.SetIPFamilies(api.IPv4Protocol)), 4259 expectError: true, 4260 }, { 4261 name: "ClusterIPs:v6v4_Policy:PreferDualStack_Families:v6", 4262 line: line(), 4263 svc: svctest.MakeService("foo", 4264 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 4265 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 4266 svctest.SetIPFamilies(api.IPv6Protocol)), 4267 expectPolicy: api.IPFamilyPolicyPreferDualStack, 4268 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 4269 }, { 4270 name: "ClusterIPs:v6v4_Policy:PreferDualStack_Families:v4v6", 4271 line: line(), 4272 svc: svctest.MakeService("foo", 4273 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 4274 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 4275 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 4276 expectError: true, 4277 }, { 4278 name: "ClusterIPs:v6v4_Policy:PreferDualStack_Families:v6v4", 4279 line: line(), 4280 svc: svctest.MakeService("foo", 4281 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 4282 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 4283 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 4284 expectPolicy: api.IPFamilyPolicyPreferDualStack, 4285 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 4286 }, { 4287 name: "ClusterIPs:v6v4_Policy:RequireDualStack_Families:unset", 4288 line: line(), 4289 svc: svctest.MakeService("foo", 4290 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 4291 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack)), 4292 expectPolicy: api.IPFamilyPolicyRequireDualStack, 4293 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 4294 }, { 4295 name: "ClusterIPs:v6v4_Policy:RequireDualStack_Families:v4", 4296 line: line(), 4297 svc: svctest.MakeService("foo", 4298 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 4299 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 4300 svctest.SetIPFamilies(api.IPv4Protocol)), 4301 expectError: true, 4302 }, { 4303 name: "ClusterIPs:v6v4_Policy:RequireDualStack_Families:v6", 4304 line: line(), 4305 svc: svctest.MakeService("foo", 4306 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 4307 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 4308 svctest.SetIPFamilies(api.IPv6Protocol)), 4309 expectPolicy: api.IPFamilyPolicyRequireDualStack, 4310 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 4311 }, { 4312 name: "ClusterIPs:v6v4_Policy:RequireDualStack_Families:v4v6", 4313 line: line(), 4314 svc: svctest.MakeService("foo", 4315 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 4316 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 4317 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 4318 expectError: true, 4319 }, { 4320 name: "ClusterIPs:v6v4_Policy:RequireDualStack_Families:v6v4", 4321 line: line(), 4322 svc: svctest.MakeService("foo", 4323 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 4324 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 4325 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 4326 expectPolicy: api.IPFamilyPolicyRequireDualStack, 4327 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 4328 }, 4329 //---------------------------------------- 4330 // dualstack:v4v6 Headless 4331 //---------------------------------------- 4332 { 4333 name: "Headless_Policy:unset_Families:unset", 4334 line: line(), 4335 svc: svctest.MakeService("foo", 4336 svctest.SetHeadless), 4337 expectPolicy: api.IPFamilyPolicySingleStack, 4338 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 4339 expectHeadless: true, 4340 }, { 4341 name: "Headless_Policy:unset_Families:v4", 4342 line: line(), 4343 svc: svctest.MakeService("foo", 4344 svctest.SetHeadless, 4345 svctest.SetIPFamilies(api.IPv4Protocol)), 4346 expectPolicy: api.IPFamilyPolicySingleStack, 4347 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 4348 expectHeadless: true, 4349 }, { 4350 name: "Headless_Policy:unset_Families:v6", 4351 line: line(), 4352 svc: svctest.MakeService("foo", 4353 svctest.SetHeadless, 4354 svctest.SetIPFamilies(api.IPv6Protocol)), 4355 expectPolicy: api.IPFamilyPolicySingleStack, 4356 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 4357 expectHeadless: true, 4358 }, { 4359 name: "Headless_Policy:unset_Families:v4v6", 4360 line: line(), 4361 svc: svctest.MakeService("foo", 4362 svctest.SetHeadless, 4363 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 4364 expectError: true, 4365 }, { 4366 name: "Headless_Policy:unset_Families:v6v4", 4367 line: line(), 4368 svc: svctest.MakeService("foo", 4369 svctest.SetHeadless, 4370 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 4371 expectError: true, 4372 }, { 4373 name: "Headless_Policy:SingleStack_Families:unset", 4374 line: line(), 4375 svc: svctest.MakeService("foo", 4376 svctest.SetHeadless, 4377 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack)), 4378 expectPolicy: api.IPFamilyPolicySingleStack, 4379 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 4380 expectHeadless: true, 4381 }, { 4382 name: "Headless_Policy:SingleStack_Families:v4", 4383 line: line(), 4384 svc: svctest.MakeService("foo", 4385 svctest.SetHeadless, 4386 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 4387 svctest.SetIPFamilies(api.IPv4Protocol)), 4388 expectPolicy: api.IPFamilyPolicySingleStack, 4389 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 4390 expectHeadless: true, 4391 }, { 4392 name: "Headless_Policy:SingleStack_Families:v6", 4393 line: line(), 4394 svc: svctest.MakeService("foo", 4395 svctest.SetHeadless, 4396 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 4397 svctest.SetIPFamilies(api.IPv6Protocol)), 4398 expectPolicy: api.IPFamilyPolicySingleStack, 4399 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 4400 expectHeadless: true, 4401 }, { 4402 name: "Headless_Policy:SingleStack_Families:v4v6", 4403 line: line(), 4404 svc: svctest.MakeService("foo", 4405 svctest.SetHeadless, 4406 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 4407 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 4408 expectError: true, 4409 }, { 4410 name: "Headless_Policy:SingleStack_Families:v6v4", 4411 line: line(), 4412 svc: svctest.MakeService("foo", 4413 svctest.SetHeadless, 4414 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 4415 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 4416 expectError: true, 4417 }, { 4418 name: "Headless_Policy:PreferDualStack_Families:unset", 4419 line: line(), 4420 svc: svctest.MakeService("foo", 4421 svctest.SetHeadless, 4422 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack)), 4423 expectPolicy: api.IPFamilyPolicyPreferDualStack, 4424 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 4425 expectHeadless: true, 4426 }, { 4427 name: "Headless_Policy:PreferDualStack_Families:v4", 4428 line: line(), 4429 svc: svctest.MakeService("foo", 4430 svctest.SetHeadless, 4431 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 4432 svctest.SetIPFamilies(api.IPv4Protocol)), 4433 expectPolicy: api.IPFamilyPolicyPreferDualStack, 4434 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 4435 expectHeadless: true, 4436 }, { 4437 name: "Headless_Policy:PreferDualStack_Families:v6", 4438 line: line(), 4439 svc: svctest.MakeService("foo", 4440 svctest.SetHeadless, 4441 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 4442 svctest.SetIPFamilies(api.IPv6Protocol)), 4443 expectPolicy: api.IPFamilyPolicyPreferDualStack, 4444 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 4445 expectHeadless: true, 4446 }, { 4447 name: "Headless_Policy:PreferDualStack_Families:v4v6", 4448 line: line(), 4449 svc: svctest.MakeService("foo", 4450 svctest.SetHeadless, 4451 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 4452 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 4453 expectPolicy: api.IPFamilyPolicyPreferDualStack, 4454 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 4455 expectHeadless: true, 4456 }, { 4457 name: "Headless_Policy:PreferDualStack_Families:v6v4", 4458 line: line(), 4459 svc: svctest.MakeService("foo", 4460 svctest.SetHeadless, 4461 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 4462 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 4463 expectPolicy: api.IPFamilyPolicyPreferDualStack, 4464 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 4465 expectHeadless: true, 4466 }, { 4467 name: "Headless_Policy:RequireDualStack_Families:unset", 4468 line: line(), 4469 svc: svctest.MakeService("foo", 4470 svctest.SetHeadless, 4471 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack)), 4472 expectPolicy: api.IPFamilyPolicyRequireDualStack, 4473 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 4474 expectHeadless: true, 4475 }, { 4476 name: "Headless_Policy:RequireDualStack_Families:v4", 4477 line: line(), 4478 svc: svctest.MakeService("foo", 4479 svctest.SetHeadless, 4480 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 4481 svctest.SetIPFamilies(api.IPv4Protocol)), 4482 expectPolicy: api.IPFamilyPolicyRequireDualStack, 4483 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 4484 expectHeadless: true, 4485 }, { 4486 name: "Headless_Policy:RequireDualStack_Families:v6", 4487 line: line(), 4488 svc: svctest.MakeService("foo", 4489 svctest.SetHeadless, 4490 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 4491 svctest.SetIPFamilies(api.IPv6Protocol)), 4492 expectPolicy: api.IPFamilyPolicyRequireDualStack, 4493 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 4494 expectHeadless: true, 4495 }, { 4496 name: "Headless_Policy:RequireDualStack_Families:v4v6", 4497 line: line(), 4498 svc: svctest.MakeService("foo", 4499 svctest.SetHeadless, 4500 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 4501 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 4502 expectPolicy: api.IPFamilyPolicyRequireDualStack, 4503 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 4504 expectHeadless: true, 4505 }, { 4506 name: "Headless_Policy:RequireDualStack_Families:v6v4", 4507 line: line(), 4508 svc: svctest.MakeService("foo", 4509 svctest.SetHeadless, 4510 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 4511 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 4512 expectPolicy: api.IPFamilyPolicyRequireDualStack, 4513 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 4514 expectHeadless: true, 4515 }, 4516 //---------------------------------------- 4517 // dualstack:v4v6 HeadlessSelectorless 4518 //---------------------------------------- 4519 { 4520 name: "HeadlessSelectorless_Policy:unset_Families:unset", 4521 line: line(), 4522 svc: svctest.MakeService("foo", 4523 svctest.SetHeadless, 4524 svctest.SetSelector(nil)), 4525 expectPolicy: api.IPFamilyPolicyRequireDualStack, 4526 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 4527 expectHeadless: true, 4528 }, { 4529 name: "HeadlessSelectorless_Policy:unset_Families:v4", 4530 line: line(), 4531 svc: svctest.MakeService("foo", 4532 svctest.SetHeadless, 4533 svctest.SetSelector(nil), 4534 svctest.SetIPFamilies(api.IPv4Protocol)), 4535 expectPolicy: api.IPFamilyPolicyRequireDualStack, 4536 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 4537 expectHeadless: true, 4538 }, { 4539 name: "HeadlessSelectorless_Policy:unset_Families:v6", 4540 line: line(), 4541 svc: svctest.MakeService("foo", 4542 svctest.SetHeadless, 4543 svctest.SetSelector(nil), 4544 svctest.SetIPFamilies(api.IPv6Protocol)), 4545 expectPolicy: api.IPFamilyPolicyRequireDualStack, 4546 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 4547 expectHeadless: true, 4548 }, { 4549 name: "HeadlessSelectorless_Policy:unset_Families:v4v6", 4550 line: line(), 4551 svc: svctest.MakeService("foo", 4552 svctest.SetHeadless, 4553 svctest.SetSelector(nil), 4554 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 4555 expectPolicy: api.IPFamilyPolicyRequireDualStack, 4556 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 4557 expectHeadless: true, 4558 }, { 4559 name: "HeadlessSelectorless_Policy:unset_Families:v6v4", 4560 line: line(), 4561 svc: svctest.MakeService("foo", 4562 svctest.SetHeadless, 4563 svctest.SetSelector(nil), 4564 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 4565 expectPolicy: api.IPFamilyPolicyRequireDualStack, 4566 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 4567 expectHeadless: true, 4568 }, { 4569 name: "HeadlessSelectorless_Policy:SingleStack_Families:unset", 4570 line: line(), 4571 svc: svctest.MakeService("foo", 4572 svctest.SetHeadless, 4573 svctest.SetSelector(nil), 4574 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack)), 4575 expectPolicy: api.IPFamilyPolicySingleStack, 4576 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 4577 expectHeadless: true, 4578 }, { 4579 name: "HeadlessSelectorless_Policy:SingleStack_Families:v4", 4580 line: line(), 4581 svc: svctest.MakeService("foo", 4582 svctest.SetHeadless, 4583 svctest.SetSelector(nil), 4584 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 4585 svctest.SetIPFamilies(api.IPv4Protocol)), 4586 expectPolicy: api.IPFamilyPolicySingleStack, 4587 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 4588 expectHeadless: true, 4589 }, { 4590 name: "HeadlessSelectorless_Policy:SingleStack_Families:v6", 4591 line: line(), 4592 svc: svctest.MakeService("foo", 4593 svctest.SetHeadless, 4594 svctest.SetSelector(nil), 4595 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 4596 svctest.SetIPFamilies(api.IPv6Protocol)), 4597 expectPolicy: api.IPFamilyPolicySingleStack, 4598 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 4599 expectHeadless: true, 4600 }, { 4601 name: "HeadlessSelectorless_Policy:SingleStack_Families:v4v6", 4602 line: line(), 4603 svc: svctest.MakeService("foo", 4604 svctest.SetHeadless, 4605 svctest.SetSelector(nil), 4606 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 4607 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 4608 expectError: true, 4609 }, { 4610 name: "HeadlessSelectorless_Policy:SingleStack_Families:v6v4", 4611 line: line(), 4612 svc: svctest.MakeService("foo", 4613 svctest.SetHeadless, 4614 svctest.SetSelector(nil), 4615 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 4616 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 4617 expectError: true, 4618 }, { 4619 name: "HeadlessSelectorless_Policy:PreferDualStack_Families:unset", 4620 line: line(), 4621 svc: svctest.MakeService("foo", 4622 svctest.SetHeadless, 4623 svctest.SetSelector(nil), 4624 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack)), 4625 expectPolicy: api.IPFamilyPolicyPreferDualStack, 4626 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 4627 expectHeadless: true, 4628 }, { 4629 name: "HeadlessSelectorless_Policy:PreferDualStack_Families:v4", 4630 line: line(), 4631 svc: svctest.MakeService("foo", 4632 svctest.SetHeadless, 4633 svctest.SetSelector(nil), 4634 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 4635 svctest.SetIPFamilies(api.IPv4Protocol)), 4636 expectPolicy: api.IPFamilyPolicyPreferDualStack, 4637 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 4638 expectHeadless: true, 4639 }, { 4640 name: "HeadlessSelectorless_Policy:PreferDualStack_Families:v6", 4641 line: line(), 4642 svc: svctest.MakeService("foo", 4643 svctest.SetHeadless, 4644 svctest.SetSelector(nil), 4645 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 4646 svctest.SetIPFamilies(api.IPv6Protocol)), 4647 expectPolicy: api.IPFamilyPolicyPreferDualStack, 4648 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 4649 expectHeadless: true, 4650 }, { 4651 name: "HeadlessSelectorless_Policy:PreferDualStack_Families:v4v6", 4652 line: line(), 4653 svc: svctest.MakeService("foo", 4654 svctest.SetHeadless, 4655 svctest.SetSelector(nil), 4656 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 4657 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 4658 expectPolicy: api.IPFamilyPolicyPreferDualStack, 4659 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 4660 expectHeadless: true, 4661 }, { 4662 name: "HeadlessSelectorless_Policy:PreferDualStack_Families:v6v4", 4663 line: line(), 4664 svc: svctest.MakeService("foo", 4665 svctest.SetHeadless, 4666 svctest.SetSelector(nil), 4667 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 4668 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 4669 expectPolicy: api.IPFamilyPolicyPreferDualStack, 4670 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 4671 expectHeadless: true, 4672 }, { 4673 name: "HeadlessSelectorless_Policy:RequireDualStack_Families:unset", 4674 line: line(), 4675 svc: svctest.MakeService("foo", 4676 svctest.SetHeadless, 4677 svctest.SetSelector(nil), 4678 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack)), 4679 expectPolicy: api.IPFamilyPolicyRequireDualStack, 4680 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 4681 expectHeadless: true, 4682 }, { 4683 name: "HeadlessSelectorless_Policy:RequireDualStack_Families:v4", 4684 line: line(), 4685 svc: svctest.MakeService("foo", 4686 svctest.SetHeadless, 4687 svctest.SetSelector(nil), 4688 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 4689 svctest.SetIPFamilies(api.IPv4Protocol)), 4690 expectPolicy: api.IPFamilyPolicyRequireDualStack, 4691 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 4692 expectHeadless: true, 4693 }, { 4694 name: "HeadlessSelectorless_Policy:RequireDualStack_Families:v6", 4695 line: line(), 4696 svc: svctest.MakeService("foo", 4697 svctest.SetHeadless, 4698 svctest.SetSelector(nil), 4699 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 4700 svctest.SetIPFamilies(api.IPv6Protocol)), 4701 expectPolicy: api.IPFamilyPolicyRequireDualStack, 4702 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 4703 expectHeadless: true, 4704 }, { 4705 name: "HeadlessSelectorless_Policy:RequireDualStack_Families:v4v6", 4706 line: line(), 4707 svc: svctest.MakeService("foo", 4708 svctest.SetHeadless, 4709 svctest.SetSelector(nil), 4710 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 4711 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 4712 expectPolicy: api.IPFamilyPolicyRequireDualStack, 4713 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 4714 expectHeadless: true, 4715 }, { 4716 name: "HeadlessSelectorless_Policy:RequireDualStack_Families:v6v4", 4717 line: line(), 4718 svc: svctest.MakeService("foo", 4719 svctest.SetHeadless, 4720 svctest.SetSelector(nil), 4721 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 4722 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 4723 expectPolicy: api.IPFamilyPolicyRequireDualStack, 4724 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 4725 expectHeadless: true, 4726 }, 4727 }, 4728 }, { 4729 name: "dualstack:v6v4", 4730 clusterFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 4731 cases: []testCase{ 4732 //---------------------------------------- 4733 // dualstack:v6v4 ClusterIPs:unset 4734 //---------------------------------------- 4735 { 4736 name: "ClusterIPs:unset_Policy:unset_Families:unset", 4737 line: line(), 4738 svc: svctest.MakeService("foo"), 4739 expectPolicy: api.IPFamilyPolicySingleStack, 4740 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 4741 }, { 4742 name: "ClusterIPs:unset_Policy:unset_Families:v4", 4743 line: line(), 4744 svc: svctest.MakeService("foo", 4745 svctest.SetIPFamilies(api.IPv4Protocol)), 4746 expectPolicy: api.IPFamilyPolicySingleStack, 4747 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 4748 }, { 4749 name: "ClusterIPs:unset_Policy:unset_Families:v6", 4750 line: line(), 4751 svc: svctest.MakeService("foo", 4752 svctest.SetIPFamilies(api.IPv6Protocol)), 4753 expectPolicy: api.IPFamilyPolicySingleStack, 4754 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 4755 }, { 4756 name: "ClusterIPs:unset_Policy:unset_Families:v4v6", 4757 line: line(), 4758 svc: svctest.MakeService("foo", 4759 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 4760 expectError: true, 4761 }, { 4762 name: "ClusterIPs:unset_Policy:unset_Families:v6v4", 4763 line: line(), 4764 svc: svctest.MakeService("foo", 4765 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 4766 expectError: true, 4767 }, { 4768 name: "ClusterIPs:unset_Policy:SingleStack_Families:unset", 4769 line: line(), 4770 svc: svctest.MakeService("foo", 4771 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack)), 4772 expectPolicy: api.IPFamilyPolicySingleStack, 4773 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 4774 }, { 4775 name: "ClusterIPs:unset_Policy:SingleStack_Families:v4", 4776 line: line(), 4777 svc: svctest.MakeService("foo", 4778 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 4779 svctest.SetIPFamilies(api.IPv4Protocol)), 4780 expectPolicy: api.IPFamilyPolicySingleStack, 4781 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 4782 }, { 4783 name: "ClusterIPs:unset_Policy:SingleStack_Families:v6", 4784 line: line(), 4785 svc: svctest.MakeService("foo", 4786 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 4787 svctest.SetIPFamilies(api.IPv6Protocol)), 4788 expectPolicy: api.IPFamilyPolicySingleStack, 4789 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 4790 }, { 4791 name: "ClusterIPs:unset_Policy:SingleStack_Families:v4v6", 4792 line: line(), 4793 svc: svctest.MakeService("foo", 4794 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 4795 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 4796 expectError: true, 4797 }, { 4798 name: "ClusterIPs:unset_Policy:SingleStack_Families:v6v4", 4799 line: line(), 4800 svc: svctest.MakeService("foo", 4801 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 4802 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 4803 expectError: true, 4804 }, { 4805 name: "ClusterIPs:unset_Policy:PreferDualStack_Families:unset", 4806 line: line(), 4807 svc: svctest.MakeService("foo", 4808 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack)), 4809 expectPolicy: api.IPFamilyPolicyPreferDualStack, 4810 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 4811 }, { 4812 name: "ClusterIPs:unset_Policy:PreferDualStack_Families:v4", 4813 line: line(), 4814 svc: svctest.MakeService("foo", 4815 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 4816 svctest.SetIPFamilies(api.IPv4Protocol)), 4817 expectPolicy: api.IPFamilyPolicyPreferDualStack, 4818 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 4819 }, { 4820 name: "ClusterIPs:unset_Policy:PreferDualStack_Families:v6", 4821 line: line(), 4822 svc: svctest.MakeService("foo", 4823 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 4824 svctest.SetIPFamilies(api.IPv6Protocol)), 4825 expectPolicy: api.IPFamilyPolicyPreferDualStack, 4826 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 4827 }, { 4828 name: "ClusterIPs:unset_Policy:PreferDualStack_Families:v4v6", 4829 line: line(), 4830 svc: svctest.MakeService("foo", 4831 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 4832 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 4833 expectPolicy: api.IPFamilyPolicyPreferDualStack, 4834 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 4835 }, { 4836 name: "ClusterIPs:unset_Policy:PreferDualStack_Families:v6v4", 4837 line: line(), 4838 svc: svctest.MakeService("foo", 4839 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 4840 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 4841 expectPolicy: api.IPFamilyPolicyPreferDualStack, 4842 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 4843 }, { 4844 name: "ClusterIPs:unset_Policy:RequireDualStack_Families:unset", 4845 line: line(), 4846 svc: svctest.MakeService("foo", 4847 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack)), 4848 expectPolicy: api.IPFamilyPolicyRequireDualStack, 4849 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 4850 }, { 4851 name: "ClusterIPs:unset_Policy:RequireDualStack_Families:v4", 4852 line: line(), 4853 svc: svctest.MakeService("foo", 4854 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 4855 svctest.SetIPFamilies(api.IPv4Protocol)), 4856 expectPolicy: api.IPFamilyPolicyRequireDualStack, 4857 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 4858 }, { 4859 name: "ClusterIPs:unset_Policy:RequireDualStack_Families:v6", 4860 line: line(), 4861 svc: svctest.MakeService("foo", 4862 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 4863 svctest.SetIPFamilies(api.IPv6Protocol)), 4864 expectPolicy: api.IPFamilyPolicyRequireDualStack, 4865 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 4866 }, { 4867 name: "ClusterIPs:unset_Policy:RequireDualStack_Families:v4v6", 4868 line: line(), 4869 svc: svctest.MakeService("foo", 4870 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 4871 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 4872 expectPolicy: api.IPFamilyPolicyRequireDualStack, 4873 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 4874 }, { 4875 name: "ClusterIPs:unset_Policy:RequireDualStack_Families:v6v4", 4876 line: line(), 4877 svc: svctest.MakeService("foo", 4878 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 4879 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 4880 expectPolicy: api.IPFamilyPolicyRequireDualStack, 4881 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 4882 }, 4883 //---------------------------------------- 4884 // dualstack:v6v4 ClusterIPs:v4 4885 //---------------------------------------- 4886 { 4887 name: "ClusterIPs:v4_Policy:unset_Families:unset", 4888 line: line(), 4889 svc: svctest.MakeService("foo", 4890 svctest.SetClusterIPs("10.0.0.1")), 4891 expectPolicy: api.IPFamilyPolicySingleStack, 4892 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 4893 }, { 4894 name: "ClusterIPs:v4_Policy:unset_Families:v4", 4895 line: line(), 4896 svc: svctest.MakeService("foo", 4897 svctest.SetClusterIPs("10.0.0.1"), 4898 svctest.SetIPFamilies(api.IPv4Protocol)), 4899 expectPolicy: api.IPFamilyPolicySingleStack, 4900 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 4901 }, { 4902 name: "ClusterIPs:v4_Policy:unset_Families:v6", 4903 line: line(), 4904 svc: svctest.MakeService("foo", 4905 svctest.SetClusterIPs("10.0.0.1"), 4906 svctest.SetIPFamilies(api.IPv6Protocol)), 4907 expectError: true, 4908 }, { 4909 name: "ClusterIPs:v4_Policy:unset_Families:v4v6", 4910 line: line(), 4911 svc: svctest.MakeService("foo", 4912 svctest.SetClusterIPs("10.0.0.1"), 4913 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 4914 expectError: true, 4915 }, { 4916 name: "ClusterIPs:v4_Policy:unset_Families:v6v4", 4917 line: line(), 4918 svc: svctest.MakeService("foo", 4919 svctest.SetClusterIPs("10.0.0.1"), 4920 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 4921 expectError: true, 4922 }, { 4923 name: "ClusterIPs:v4_Policy:SingleStack_Families:unset", 4924 line: line(), 4925 svc: svctest.MakeService("foo", 4926 svctest.SetClusterIPs("10.0.0.1"), 4927 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack)), 4928 expectPolicy: api.IPFamilyPolicySingleStack, 4929 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 4930 }, { 4931 name: "ClusterIPs:v4_Policy:SingleStack_Families:v4", 4932 line: line(), 4933 svc: svctest.MakeService("foo", 4934 svctest.SetClusterIPs("10.0.0.1"), 4935 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 4936 svctest.SetIPFamilies(api.IPv4Protocol)), 4937 expectPolicy: api.IPFamilyPolicySingleStack, 4938 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 4939 }, { 4940 name: "ClusterIPs:v4_Policy:SingleStack_Families:v6", 4941 line: line(), 4942 svc: svctest.MakeService("foo", 4943 svctest.SetClusterIPs("10.0.0.1"), 4944 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 4945 svctest.SetIPFamilies(api.IPv6Protocol)), 4946 expectError: true, 4947 }, { 4948 name: "ClusterIPs:v4_Policy:SingleStack_Families:v4v6", 4949 line: line(), 4950 svc: svctest.MakeService("foo", 4951 svctest.SetClusterIPs("10.0.0.1"), 4952 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 4953 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 4954 expectError: true, 4955 }, { 4956 name: "ClusterIPs:v4_Policy:SingleStack_Families:v6v4", 4957 line: line(), 4958 svc: svctest.MakeService("foo", 4959 svctest.SetClusterIPs("10.0.0.1"), 4960 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 4961 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 4962 expectError: true, 4963 }, { 4964 name: "ClusterIPs:v4_Policy:PreferDualStack_Families:unset", 4965 line: line(), 4966 svc: svctest.MakeService("foo", 4967 svctest.SetClusterIPs("10.0.0.1"), 4968 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack)), 4969 expectPolicy: api.IPFamilyPolicyPreferDualStack, 4970 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 4971 }, { 4972 name: "ClusterIPs:v4_Policy:PreferDualStack_Families:v4", 4973 line: line(), 4974 svc: svctest.MakeService("foo", 4975 svctest.SetClusterIPs("10.0.0.1"), 4976 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 4977 svctest.SetIPFamilies(api.IPv4Protocol)), 4978 expectPolicy: api.IPFamilyPolicyPreferDualStack, 4979 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 4980 }, { 4981 name: "ClusterIPs:v4_Policy:PreferDualStack_Families:v6", 4982 line: line(), 4983 svc: svctest.MakeService("foo", 4984 svctest.SetClusterIPs("10.0.0.1"), 4985 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 4986 svctest.SetIPFamilies(api.IPv6Protocol)), 4987 expectError: true, 4988 }, { 4989 name: "ClusterIPs:v4_Policy:PreferDualStack_Families:v4v6", 4990 line: line(), 4991 svc: svctest.MakeService("foo", 4992 svctest.SetClusterIPs("10.0.0.1"), 4993 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 4994 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 4995 expectPolicy: api.IPFamilyPolicyPreferDualStack, 4996 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 4997 }, { 4998 name: "ClusterIPs:v4_Policy:PreferDualStack_Families:v6v4", 4999 line: line(), 5000 svc: svctest.MakeService("foo", 5001 svctest.SetClusterIPs("10.0.0.1"), 5002 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 5003 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 5004 expectError: true, 5005 }, { 5006 name: "ClusterIPs:v4_Policy:RequireDualStack_Families:unset", 5007 line: line(), 5008 svc: svctest.MakeService("foo", 5009 svctest.SetClusterIPs("10.0.0.1"), 5010 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack)), 5011 expectPolicy: api.IPFamilyPolicyRequireDualStack, 5012 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 5013 }, { 5014 name: "ClusterIPs:v4_Policy:RequireDualStack_Families:v4", 5015 line: line(), 5016 svc: svctest.MakeService("foo", 5017 svctest.SetClusterIPs("10.0.0.1"), 5018 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 5019 svctest.SetIPFamilies(api.IPv4Protocol)), 5020 expectPolicy: api.IPFamilyPolicyRequireDualStack, 5021 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 5022 }, { 5023 name: "ClusterIPs:v4_Policy:RequireDualStack_Families:v6", 5024 line: line(), 5025 svc: svctest.MakeService("foo", 5026 svctest.SetClusterIPs("10.0.0.1"), 5027 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 5028 svctest.SetIPFamilies(api.IPv6Protocol)), 5029 expectError: true, 5030 }, { 5031 name: "ClusterIPs:v4_Policy:RequireDualStack_Families:v4v6", 5032 line: line(), 5033 svc: svctest.MakeService("foo", 5034 svctest.SetClusterIPs("10.0.0.1"), 5035 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 5036 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 5037 expectPolicy: api.IPFamilyPolicyRequireDualStack, 5038 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 5039 }, { 5040 name: "ClusterIPs:v4_Policy:RequireDualStack_Families:v6v4", 5041 line: line(), 5042 svc: svctest.MakeService("foo", 5043 svctest.SetClusterIPs("10.0.0.1"), 5044 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 5045 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 5046 expectError: true, 5047 }, 5048 //---------------------------------------- 5049 // dualstack:v6v4 ClusterIPs:v6 5050 //---------------------------------------- 5051 { 5052 name: "ClusterIPs:v6_Policy:unset_Families:unset", 5053 line: line(), 5054 svc: svctest.MakeService("foo", 5055 svctest.SetClusterIPs("2000::1")), 5056 expectPolicy: api.IPFamilyPolicySingleStack, 5057 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 5058 }, { 5059 name: "ClusterIPs:v6_Policy:unset_Families:v4", 5060 line: line(), 5061 svc: svctest.MakeService("foo", 5062 svctest.SetClusterIPs("2000::1"), 5063 svctest.SetIPFamilies(api.IPv4Protocol)), 5064 expectError: true, 5065 }, { 5066 name: "ClusterIPs:v6_Policy:unset_Families:v6", 5067 line: line(), 5068 svc: svctest.MakeService("foo", 5069 svctest.SetClusterIPs("2000::1"), 5070 svctest.SetIPFamilies(api.IPv6Protocol)), 5071 expectPolicy: api.IPFamilyPolicySingleStack, 5072 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 5073 }, { 5074 name: "ClusterIPs:v6_Policy:unset_Families:v4v6", 5075 line: line(), 5076 svc: svctest.MakeService("foo", 5077 svctest.SetClusterIPs("2000::1"), 5078 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 5079 expectError: true, 5080 }, { 5081 name: "ClusterIPs:v6_Policy:unset_Families:v6v4", 5082 line: line(), 5083 svc: svctest.MakeService("foo", 5084 svctest.SetClusterIPs("2000::1"), 5085 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 5086 expectError: true, 5087 }, { 5088 name: "ClusterIPs:v6_Policy:SingleStack_Families:unset", 5089 line: line(), 5090 svc: svctest.MakeService("foo", 5091 svctest.SetClusterIPs("2000::1"), 5092 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack)), 5093 expectPolicy: api.IPFamilyPolicySingleStack, 5094 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 5095 }, { 5096 name: "ClusterIPs:v6_Policy:SingleStack_Families:v4", 5097 line: line(), 5098 svc: svctest.MakeService("foo", 5099 svctest.SetClusterIPs("2000::1"), 5100 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 5101 svctest.SetIPFamilies(api.IPv4Protocol)), 5102 expectError: true, 5103 }, { 5104 name: "ClusterIPs:v6_Policy:SingleStack_Families:v6", 5105 line: line(), 5106 svc: svctest.MakeService("foo", 5107 svctest.SetClusterIPs("2000::1"), 5108 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 5109 svctest.SetIPFamilies(api.IPv6Protocol)), 5110 expectPolicy: api.IPFamilyPolicySingleStack, 5111 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 5112 }, { 5113 name: "ClusterIPs:v6_Policy:SingleStack_Families:v4v6", 5114 line: line(), 5115 svc: svctest.MakeService("foo", 5116 svctest.SetClusterIPs("2000::1"), 5117 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 5118 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 5119 expectError: true, 5120 }, { 5121 name: "ClusterIPs:v6_Policy:SingleStack_Families:v6v4", 5122 line: line(), 5123 svc: svctest.MakeService("foo", 5124 svctest.SetClusterIPs("2000::1"), 5125 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 5126 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 5127 expectError: true, 5128 }, { 5129 name: "ClusterIPs:v6_Policy:PreferDualStack_Families:unset", 5130 line: line(), 5131 svc: svctest.MakeService("foo", 5132 svctest.SetClusterIPs("2000::1"), 5133 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack)), 5134 expectPolicy: api.IPFamilyPolicyPreferDualStack, 5135 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 5136 }, { 5137 name: "ClusterIPs:v6_Policy:PreferDualStack_Families:v4", 5138 line: line(), 5139 svc: svctest.MakeService("foo", 5140 svctest.SetClusterIPs("2000::1"), 5141 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 5142 svctest.SetIPFamilies(api.IPv4Protocol)), 5143 expectError: true, 5144 }, { 5145 name: "ClusterIPs:v6_Policy:PreferDualStack_Families:v6", 5146 line: line(), 5147 svc: svctest.MakeService("foo", 5148 svctest.SetClusterIPs("2000::1"), 5149 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 5150 svctest.SetIPFamilies(api.IPv6Protocol)), 5151 expectPolicy: api.IPFamilyPolicyPreferDualStack, 5152 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 5153 }, { 5154 name: "ClusterIPs:v6_Policy:PreferDualStack_Families:v4v6", 5155 line: line(), 5156 svc: svctest.MakeService("foo", 5157 svctest.SetClusterIPs("2000::1"), 5158 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 5159 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 5160 expectError: true, 5161 }, { 5162 name: "ClusterIPs:v6_Policy:PreferDualStack_Families:v6v4", 5163 line: line(), 5164 svc: svctest.MakeService("foo", 5165 svctest.SetClusterIPs("2000::1"), 5166 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 5167 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 5168 expectPolicy: api.IPFamilyPolicyPreferDualStack, 5169 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 5170 }, { 5171 name: "ClusterIPs:v6_Policy:RequireDualStack_Families:unset", 5172 line: line(), 5173 svc: svctest.MakeService("foo", 5174 svctest.SetClusterIPs("2000::1"), 5175 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack)), 5176 expectPolicy: api.IPFamilyPolicyRequireDualStack, 5177 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 5178 }, { 5179 name: "ClusterIPs:v6_Policy:RequireDualStack_Families:v4", 5180 line: line(), 5181 svc: svctest.MakeService("foo", 5182 svctest.SetClusterIPs("2000::1"), 5183 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 5184 svctest.SetIPFamilies(api.IPv4Protocol)), 5185 expectError: true, 5186 }, { 5187 name: "ClusterIPs:v6_Policy:RequireDualStack_Families:v6", 5188 line: line(), 5189 svc: svctest.MakeService("foo", 5190 svctest.SetClusterIPs("2000::1"), 5191 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 5192 svctest.SetIPFamilies(api.IPv6Protocol)), 5193 expectPolicy: api.IPFamilyPolicyRequireDualStack, 5194 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 5195 }, { 5196 name: "ClusterIPs:v6_Policy:RequireDualStack_Families:v4v6", 5197 line: line(), 5198 svc: svctest.MakeService("foo", 5199 svctest.SetClusterIPs("2000::1"), 5200 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 5201 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 5202 expectError: true, 5203 }, { 5204 name: "ClusterIPs:v6_Policy:RequireDualStack_Families:v6v4", 5205 line: line(), 5206 svc: svctest.MakeService("foo", 5207 svctest.SetClusterIPs("2000::1"), 5208 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 5209 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 5210 expectPolicy: api.IPFamilyPolicyRequireDualStack, 5211 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 5212 }, 5213 //---------------------------------------- 5214 // dualstack:v6v4 ClusterIPs:v4v6 5215 //---------------------------------------- 5216 { 5217 name: "ClusterIPs:v4v6_Policy:unset_Families:unset", 5218 line: line(), 5219 svc: svctest.MakeService("foo", 5220 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 5221 expectError: true, 5222 }, { 5223 name: "ClusterIPs:v4v6_Policy:unset_Families:v4", 5224 line: line(), 5225 svc: svctest.MakeService("foo", 5226 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 5227 svctest.SetIPFamilies(api.IPv4Protocol)), 5228 expectError: true, 5229 }, { 5230 name: "ClusterIPs:v4v6_Policy:unset_Families:v6", 5231 line: line(), 5232 svc: svctest.MakeService("foo", 5233 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 5234 svctest.SetIPFamilies(api.IPv6Protocol)), 5235 expectError: true, 5236 }, { 5237 name: "ClusterIPs:v4v6_Policy:unset_Families:v4v6", 5238 line: line(), 5239 svc: svctest.MakeService("foo", 5240 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 5241 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 5242 expectError: true, 5243 }, { 5244 name: "ClusterIPs:v4v6_Policy:unset_Families:v6v4", 5245 line: line(), 5246 svc: svctest.MakeService("foo", 5247 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 5248 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 5249 expectError: true, 5250 }, { 5251 name: "ClusterIPs:v4v6_Policy:SingleStack_Families:unset", 5252 line: line(), 5253 svc: svctest.MakeService("foo", 5254 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 5255 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack)), 5256 expectError: true, 5257 }, { 5258 name: "ClusterIPs:v4v6_Policy:SingleStack_Families:v4", 5259 line: line(), 5260 svc: svctest.MakeService("foo", 5261 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 5262 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 5263 svctest.SetIPFamilies(api.IPv4Protocol)), 5264 expectError: true, 5265 }, { 5266 name: "ClusterIPs:v4v6_Policy:SingleStack_Families:v6", 5267 line: line(), 5268 svc: svctest.MakeService("foo", 5269 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 5270 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 5271 svctest.SetIPFamilies(api.IPv6Protocol)), 5272 expectError: true, 5273 }, { 5274 name: "ClusterIPs:v4v6_Policy:SingleStack_Families:v4v6", 5275 line: line(), 5276 svc: svctest.MakeService("foo", 5277 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 5278 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 5279 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 5280 expectError: true, 5281 }, { 5282 name: "ClusterIPs:v4v6_Policy:SingleStack_Families:v6v4", 5283 line: line(), 5284 svc: svctest.MakeService("foo", 5285 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 5286 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 5287 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 5288 expectError: true, 5289 }, { 5290 name: "ClusterIPs:v4v6_Policy:PreferDualStack_Families:unset", 5291 line: line(), 5292 svc: svctest.MakeService("foo", 5293 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 5294 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack)), 5295 expectPolicy: api.IPFamilyPolicyPreferDualStack, 5296 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 5297 }, { 5298 name: "ClusterIPs:v4v6_Policy:PreferDualStack_Families:v4", 5299 line: line(), 5300 svc: svctest.MakeService("foo", 5301 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 5302 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 5303 svctest.SetIPFamilies(api.IPv4Protocol)), 5304 expectPolicy: api.IPFamilyPolicyPreferDualStack, 5305 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 5306 }, { 5307 name: "ClusterIPs:v4v6_Policy:PreferDualStack_Families:v6", 5308 line: line(), 5309 svc: svctest.MakeService("foo", 5310 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 5311 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 5312 svctest.SetIPFamilies(api.IPv6Protocol)), 5313 expectError: true, 5314 }, { 5315 name: "ClusterIPs:v4v6_Policy:PreferDualStack_Families:v4v6", 5316 line: line(), 5317 svc: svctest.MakeService("foo", 5318 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 5319 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 5320 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 5321 expectPolicy: api.IPFamilyPolicyPreferDualStack, 5322 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 5323 }, { 5324 name: "ClusterIPs:v4v6_Policy:PreferDualStack_Families:v6v4", 5325 line: line(), 5326 svc: svctest.MakeService("foo", 5327 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 5328 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 5329 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 5330 expectError: true, 5331 }, { 5332 name: "ClusterIPs:v4v6_Policy:RequireDualStack_Families:unset", 5333 line: line(), 5334 svc: svctest.MakeService("foo", 5335 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 5336 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack)), 5337 expectPolicy: api.IPFamilyPolicyRequireDualStack, 5338 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 5339 }, { 5340 name: "ClusterIPs:v4v6_Policy:RequireDualStack_Families:v4", 5341 line: line(), 5342 svc: svctest.MakeService("foo", 5343 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 5344 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 5345 svctest.SetIPFamilies(api.IPv4Protocol)), 5346 expectPolicy: api.IPFamilyPolicyRequireDualStack, 5347 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 5348 }, { 5349 name: "ClusterIPs:v4v6_Policy:RequireDualStack_Families:v6", 5350 line: line(), 5351 svc: svctest.MakeService("foo", 5352 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 5353 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 5354 svctest.SetIPFamilies(api.IPv6Protocol)), 5355 expectError: true, 5356 }, { 5357 name: "ClusterIPs:v4v6_Policy:RequireDualStack_Families:v4v6", 5358 line: line(), 5359 svc: svctest.MakeService("foo", 5360 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 5361 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 5362 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 5363 expectPolicy: api.IPFamilyPolicyRequireDualStack, 5364 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 5365 }, { 5366 name: "ClusterIPs:v4v6_Policy:RequireDualStack_Families:v6v4", 5367 line: line(), 5368 svc: svctest.MakeService("foo", 5369 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 5370 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 5371 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 5372 expectError: true, 5373 }, 5374 //---------------------------------------- 5375 // dualstack:v6v4 ClusterIPs:v6v4 5376 //---------------------------------------- 5377 { 5378 name: "ClusterIPs:v6v4_Policy:unset_Families:unset", 5379 line: line(), 5380 svc: svctest.MakeService("foo", 5381 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 5382 expectError: true, 5383 }, { 5384 name: "ClusterIPs:v6v4_Policy:unset_Families:v4", 5385 line: line(), 5386 svc: svctest.MakeService("foo", 5387 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 5388 svctest.SetIPFamilies(api.IPv4Protocol)), 5389 expectError: true, 5390 }, { 5391 name: "ClusterIPs:v6v4_Policy:unset_Families:v6", 5392 line: line(), 5393 svc: svctest.MakeService("foo", 5394 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 5395 svctest.SetIPFamilies(api.IPv6Protocol)), 5396 expectError: true, 5397 }, { 5398 name: "ClusterIPs:v6v4_Policy:unset_Families:v4v6", 5399 line: line(), 5400 svc: svctest.MakeService("foo", 5401 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 5402 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 5403 expectError: true, 5404 }, { 5405 name: "ClusterIPs:v6v4_Policy:unset_Families:v6v4", 5406 line: line(), 5407 svc: svctest.MakeService("foo", 5408 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 5409 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 5410 expectError: true, 5411 }, { 5412 name: "ClusterIPs:v6v4_Policy:SingleStack_Families:unset", 5413 line: line(), 5414 svc: svctest.MakeService("foo", 5415 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 5416 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack)), 5417 expectError: true, 5418 }, { 5419 name: "ClusterIPs:v6v4_Policy:SingleStack_Families:v4", 5420 line: line(), 5421 svc: svctest.MakeService("foo", 5422 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 5423 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 5424 svctest.SetIPFamilies(api.IPv4Protocol)), 5425 expectError: true, 5426 }, { 5427 name: "ClusterIPs:v6v4_Policy:SingleStack_Families:v6", 5428 line: line(), 5429 svc: svctest.MakeService("foo", 5430 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 5431 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 5432 svctest.SetIPFamilies(api.IPv6Protocol)), 5433 expectError: true, 5434 }, { 5435 name: "ClusterIPs:v6v4_Policy:SingleStack_Families:v4v6", 5436 line: line(), 5437 svc: svctest.MakeService("foo", 5438 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 5439 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 5440 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 5441 expectError: true, 5442 }, { 5443 name: "ClusterIPs:v6v4_Policy:SingleStack_Families:v6v4", 5444 line: line(), 5445 svc: svctest.MakeService("foo", 5446 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 5447 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 5448 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 5449 expectError: true, 5450 }, { 5451 name: "ClusterIPs:v6v4_Policy:PreferDualStack_Families:unset", 5452 line: line(), 5453 svc: svctest.MakeService("foo", 5454 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 5455 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack)), 5456 expectPolicy: api.IPFamilyPolicyPreferDualStack, 5457 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 5458 }, { 5459 name: "ClusterIPs:v6v4_Policy:PreferDualStack_Families:v4", 5460 line: line(), 5461 svc: svctest.MakeService("foo", 5462 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 5463 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 5464 svctest.SetIPFamilies(api.IPv4Protocol)), 5465 expectError: true, 5466 }, { 5467 name: "ClusterIPs:v6v4_Policy:PreferDualStack_Families:v6", 5468 line: line(), 5469 svc: svctest.MakeService("foo", 5470 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 5471 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 5472 svctest.SetIPFamilies(api.IPv6Protocol)), 5473 expectPolicy: api.IPFamilyPolicyPreferDualStack, 5474 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 5475 }, { 5476 name: "ClusterIPs:v6v4_Policy:PreferDualStack_Families:v4v6", 5477 line: line(), 5478 svc: svctest.MakeService("foo", 5479 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 5480 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 5481 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 5482 expectError: true, 5483 }, { 5484 name: "ClusterIPs:v6v4_Policy:PreferDualStack_Families:v6v4", 5485 line: line(), 5486 svc: svctest.MakeService("foo", 5487 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 5488 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 5489 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 5490 expectPolicy: api.IPFamilyPolicyPreferDualStack, 5491 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 5492 }, { 5493 name: "ClusterIPs:v6v4_Policy:RequireDualStack_Families:unset", 5494 line: line(), 5495 svc: svctest.MakeService("foo", 5496 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 5497 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack)), 5498 expectPolicy: api.IPFamilyPolicyRequireDualStack, 5499 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 5500 }, { 5501 name: "ClusterIPs:v6v4_Policy:RequireDualStack_Families:v4", 5502 line: line(), 5503 svc: svctest.MakeService("foo", 5504 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 5505 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 5506 svctest.SetIPFamilies(api.IPv4Protocol)), 5507 expectError: true, 5508 }, { 5509 name: "ClusterIPs:v6v4_Policy:RequireDualStack_Families:v6", 5510 line: line(), 5511 svc: svctest.MakeService("foo", 5512 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 5513 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 5514 svctest.SetIPFamilies(api.IPv6Protocol)), 5515 expectPolicy: api.IPFamilyPolicyRequireDualStack, 5516 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 5517 }, { 5518 name: "ClusterIPs:v6v4_Policy:RequireDualStack_Families:v4v6", 5519 line: line(), 5520 svc: svctest.MakeService("foo", 5521 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 5522 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 5523 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 5524 expectError: true, 5525 }, { 5526 name: "ClusterIPs:v6v4_Policy:RequireDualStack_Families:v6v4", 5527 line: line(), 5528 svc: svctest.MakeService("foo", 5529 svctest.SetClusterIPs("2000::1", "10.0.0.1"), 5530 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 5531 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 5532 expectPolicy: api.IPFamilyPolicyRequireDualStack, 5533 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 5534 }, 5535 //---------------------------------------- 5536 // dualstack:v6v4 Headless 5537 //---------------------------------------- 5538 { 5539 name: "Headless_Policy:unset_Families:unset", 5540 line: line(), 5541 svc: svctest.MakeService("foo", 5542 svctest.SetHeadless), 5543 expectPolicy: api.IPFamilyPolicySingleStack, 5544 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 5545 expectHeadless: true, 5546 }, { 5547 name: "Headless_Policy:unset_Families:v4", 5548 line: line(), 5549 svc: svctest.MakeService("foo", 5550 svctest.SetHeadless, 5551 svctest.SetIPFamilies(api.IPv4Protocol)), 5552 expectPolicy: api.IPFamilyPolicySingleStack, 5553 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 5554 expectHeadless: true, 5555 }, { 5556 name: "Headless_Policy:unset_Families:v6", 5557 line: line(), 5558 svc: svctest.MakeService("foo", 5559 svctest.SetHeadless, 5560 svctest.SetIPFamilies(api.IPv6Protocol)), 5561 expectPolicy: api.IPFamilyPolicySingleStack, 5562 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 5563 expectHeadless: true, 5564 }, { 5565 name: "Headless_Policy:unset_Families:v4v6", 5566 line: line(), 5567 svc: svctest.MakeService("foo", 5568 svctest.SetHeadless, 5569 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 5570 expectError: true, 5571 }, { 5572 name: "Headless_Policy:unset_Families:v6v4", 5573 line: line(), 5574 svc: svctest.MakeService("foo", 5575 svctest.SetHeadless, 5576 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 5577 expectError: true, 5578 }, { 5579 name: "Headless_Policy:SingleStack_Families:unset", 5580 line: line(), 5581 svc: svctest.MakeService("foo", 5582 svctest.SetHeadless, 5583 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack)), 5584 expectPolicy: api.IPFamilyPolicySingleStack, 5585 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 5586 expectHeadless: true, 5587 }, { 5588 name: "Headless_Policy:SingleStack_Families:v4", 5589 line: line(), 5590 svc: svctest.MakeService("foo", 5591 svctest.SetHeadless, 5592 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 5593 svctest.SetIPFamilies(api.IPv4Protocol)), 5594 expectPolicy: api.IPFamilyPolicySingleStack, 5595 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 5596 expectHeadless: true, 5597 }, { 5598 name: "Headless_Policy:SingleStack_Families:v6", 5599 line: line(), 5600 svc: svctest.MakeService("foo", 5601 svctest.SetHeadless, 5602 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 5603 svctest.SetIPFamilies(api.IPv6Protocol)), 5604 expectPolicy: api.IPFamilyPolicySingleStack, 5605 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 5606 expectHeadless: true, 5607 }, { 5608 name: "Headless_Policy:SingleStack_Families:v4v6", 5609 line: line(), 5610 svc: svctest.MakeService("foo", 5611 svctest.SetHeadless, 5612 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 5613 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 5614 expectError: true, 5615 }, { 5616 name: "Headless_Policy:SingleStack_Families:v6v4", 5617 line: line(), 5618 svc: svctest.MakeService("foo", 5619 svctest.SetHeadless, 5620 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 5621 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 5622 expectError: true, 5623 }, { 5624 name: "Headless_Policy:PreferDualStack_Families:unset", 5625 line: line(), 5626 svc: svctest.MakeService("foo", 5627 svctest.SetHeadless, 5628 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack)), 5629 expectPolicy: api.IPFamilyPolicyPreferDualStack, 5630 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 5631 expectHeadless: true, 5632 }, { 5633 name: "Headless_Policy:PreferDualStack_Families:v4", 5634 line: line(), 5635 svc: svctest.MakeService("foo", 5636 svctest.SetHeadless, 5637 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 5638 svctest.SetIPFamilies(api.IPv4Protocol)), 5639 expectPolicy: api.IPFamilyPolicyPreferDualStack, 5640 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 5641 expectHeadless: true, 5642 }, { 5643 name: "Headless_Policy:PreferDualStack_Families:v6", 5644 line: line(), 5645 svc: svctest.MakeService("foo", 5646 svctest.SetHeadless, 5647 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 5648 svctest.SetIPFamilies(api.IPv6Protocol)), 5649 expectPolicy: api.IPFamilyPolicyPreferDualStack, 5650 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 5651 expectHeadless: true, 5652 }, { 5653 name: "Headless_Policy:PreferDualStack_Families:v4v6", 5654 line: line(), 5655 svc: svctest.MakeService("foo", 5656 svctest.SetHeadless, 5657 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 5658 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 5659 expectPolicy: api.IPFamilyPolicyPreferDualStack, 5660 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 5661 expectHeadless: true, 5662 }, { 5663 name: "Headless_Policy:PreferDualStack_Families:v6v4", 5664 line: line(), 5665 svc: svctest.MakeService("foo", 5666 svctest.SetHeadless, 5667 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 5668 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 5669 expectPolicy: api.IPFamilyPolicyPreferDualStack, 5670 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 5671 expectHeadless: true, 5672 }, { 5673 name: "Headless_Policy:RequireDualStack_Families:unset", 5674 line: line(), 5675 svc: svctest.MakeService("foo", 5676 svctest.SetHeadless, 5677 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack)), 5678 expectPolicy: api.IPFamilyPolicyRequireDualStack, 5679 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 5680 expectHeadless: true, 5681 }, { 5682 name: "Headless_Policy:RequireDualStack_Families:v4", 5683 line: line(), 5684 svc: svctest.MakeService("foo", 5685 svctest.SetHeadless, 5686 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 5687 svctest.SetIPFamilies(api.IPv4Protocol)), 5688 expectPolicy: api.IPFamilyPolicyRequireDualStack, 5689 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 5690 expectHeadless: true, 5691 }, { 5692 name: "Headless_Policy:RequireDualStack_Families:v6", 5693 line: line(), 5694 svc: svctest.MakeService("foo", 5695 svctest.SetHeadless, 5696 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 5697 svctest.SetIPFamilies(api.IPv6Protocol)), 5698 expectPolicy: api.IPFamilyPolicyRequireDualStack, 5699 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 5700 expectHeadless: true, 5701 }, { 5702 name: "Headless_Policy:RequireDualStack_Families:v4v6", 5703 line: line(), 5704 svc: svctest.MakeService("foo", 5705 svctest.SetHeadless, 5706 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 5707 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 5708 expectPolicy: api.IPFamilyPolicyRequireDualStack, 5709 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 5710 expectHeadless: true, 5711 }, { 5712 name: "Headless_Policy:RequireDualStack_Families:v6v4", 5713 line: line(), 5714 svc: svctest.MakeService("foo", 5715 svctest.SetHeadless, 5716 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 5717 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 5718 expectPolicy: api.IPFamilyPolicyRequireDualStack, 5719 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 5720 expectHeadless: true, 5721 }, 5722 //---------------------------------------- 5723 // dualstack:v6v4 HeadlessSelectorless 5724 //---------------------------------------- 5725 { 5726 name: "HeadlessSelectorless_Policy:unset_Families:unset", 5727 line: line(), 5728 svc: svctest.MakeService("foo", 5729 svctest.SetHeadless, 5730 svctest.SetSelector(nil)), 5731 expectPolicy: api.IPFamilyPolicyRequireDualStack, 5732 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 5733 expectHeadless: true, 5734 }, { 5735 name: "HeadlessSelectorless_Policy:unset_Families:v4", 5736 line: line(), 5737 svc: svctest.MakeService("foo", 5738 svctest.SetHeadless, 5739 svctest.SetSelector(nil), 5740 svctest.SetIPFamilies(api.IPv4Protocol)), 5741 expectPolicy: api.IPFamilyPolicyRequireDualStack, 5742 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 5743 expectHeadless: true, 5744 }, { 5745 name: "HeadlessSelectorless_Policy:unset_Families:v6", 5746 line: line(), 5747 svc: svctest.MakeService("foo", 5748 svctest.SetHeadless, 5749 svctest.SetSelector(nil), 5750 svctest.SetIPFamilies(api.IPv6Protocol)), 5751 expectPolicy: api.IPFamilyPolicyRequireDualStack, 5752 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 5753 expectHeadless: true, 5754 }, { 5755 name: "HeadlessSelectorless_Policy:unset_Families:v4v6", 5756 line: line(), 5757 svc: svctest.MakeService("foo", 5758 svctest.SetHeadless, 5759 svctest.SetSelector(nil), 5760 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 5761 expectPolicy: api.IPFamilyPolicyRequireDualStack, 5762 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 5763 expectHeadless: true, 5764 }, { 5765 name: "HeadlessSelectorless_Policy:unset_Families:v6v4", 5766 line: line(), 5767 svc: svctest.MakeService("foo", 5768 svctest.SetHeadless, 5769 svctest.SetSelector(nil), 5770 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 5771 expectPolicy: api.IPFamilyPolicyRequireDualStack, 5772 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 5773 expectHeadless: true, 5774 }, { 5775 name: "HeadlessSelectorless_Policy:SingleStack_Families:unset", 5776 line: line(), 5777 svc: svctest.MakeService("foo", 5778 svctest.SetHeadless, 5779 svctest.SetSelector(nil), 5780 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack)), 5781 expectPolicy: api.IPFamilyPolicySingleStack, 5782 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 5783 expectHeadless: true, 5784 }, { 5785 name: "HeadlessSelectorless_Policy:SingleStack_Families:v4", 5786 line: line(), 5787 svc: svctest.MakeService("foo", 5788 svctest.SetHeadless, 5789 svctest.SetSelector(nil), 5790 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 5791 svctest.SetIPFamilies(api.IPv4Protocol)), 5792 expectPolicy: api.IPFamilyPolicySingleStack, 5793 expectFamilies: []api.IPFamily{api.IPv4Protocol}, 5794 expectHeadless: true, 5795 }, { 5796 name: "HeadlessSelectorless_Policy:SingleStack_Families:v6", 5797 line: line(), 5798 svc: svctest.MakeService("foo", 5799 svctest.SetHeadless, 5800 svctest.SetSelector(nil), 5801 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 5802 svctest.SetIPFamilies(api.IPv6Protocol)), 5803 expectPolicy: api.IPFamilyPolicySingleStack, 5804 expectFamilies: []api.IPFamily{api.IPv6Protocol}, 5805 expectHeadless: true, 5806 }, { 5807 name: "HeadlessSelectorless_Policy:SingleStack_Families:v4v6", 5808 line: line(), 5809 svc: svctest.MakeService("foo", 5810 svctest.SetHeadless, 5811 svctest.SetSelector(nil), 5812 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 5813 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 5814 expectError: true, 5815 }, { 5816 name: "HeadlessSelectorless_Policy:SingleStack_Families:v6v4", 5817 line: line(), 5818 svc: svctest.MakeService("foo", 5819 svctest.SetHeadless, 5820 svctest.SetSelector(nil), 5821 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 5822 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 5823 expectError: true, 5824 }, { 5825 name: "HeadlessSelectorless_Policy:PreferDualStack_Families:unset", 5826 line: line(), 5827 svc: svctest.MakeService("foo", 5828 svctest.SetHeadless, 5829 svctest.SetSelector(nil), 5830 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack)), 5831 expectPolicy: api.IPFamilyPolicyPreferDualStack, 5832 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 5833 expectHeadless: true, 5834 }, { 5835 name: "HeadlessSelectorless_Policy:PreferDualStack_Families:v4", 5836 line: line(), 5837 svc: svctest.MakeService("foo", 5838 svctest.SetHeadless, 5839 svctest.SetSelector(nil), 5840 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 5841 svctest.SetIPFamilies(api.IPv4Protocol)), 5842 expectPolicy: api.IPFamilyPolicyPreferDualStack, 5843 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 5844 expectHeadless: true, 5845 }, { 5846 name: "HeadlessSelectorless_Policy:PreferDualStack_Families:v6", 5847 line: line(), 5848 svc: svctest.MakeService("foo", 5849 svctest.SetHeadless, 5850 svctest.SetSelector(nil), 5851 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 5852 svctest.SetIPFamilies(api.IPv6Protocol)), 5853 expectPolicy: api.IPFamilyPolicyPreferDualStack, 5854 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 5855 expectHeadless: true, 5856 }, { 5857 name: "HeadlessSelectorless_Policy:PreferDualStack_Families:v4v6", 5858 line: line(), 5859 svc: svctest.MakeService("foo", 5860 svctest.SetHeadless, 5861 svctest.SetSelector(nil), 5862 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 5863 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 5864 expectPolicy: api.IPFamilyPolicyPreferDualStack, 5865 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 5866 expectHeadless: true, 5867 }, { 5868 name: "HeadlessSelectorless_Policy:PreferDualStack_Families:v6v4", 5869 line: line(), 5870 svc: svctest.MakeService("foo", 5871 svctest.SetHeadless, 5872 svctest.SetSelector(nil), 5873 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 5874 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 5875 expectPolicy: api.IPFamilyPolicyPreferDualStack, 5876 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 5877 expectHeadless: true, 5878 }, { 5879 name: "HeadlessSelectorless_Policy:RequireDualStack_Families:unset", 5880 line: line(), 5881 svc: svctest.MakeService("foo", 5882 svctest.SetHeadless, 5883 svctest.SetSelector(nil), 5884 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack)), 5885 expectPolicy: api.IPFamilyPolicyRequireDualStack, 5886 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 5887 expectHeadless: true, 5888 }, { 5889 name: "HeadlessSelectorless_Policy:RequireDualStack_Families:v4", 5890 line: line(), 5891 svc: svctest.MakeService("foo", 5892 svctest.SetHeadless, 5893 svctest.SetSelector(nil), 5894 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 5895 svctest.SetIPFamilies(api.IPv4Protocol)), 5896 expectPolicy: api.IPFamilyPolicyRequireDualStack, 5897 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 5898 expectHeadless: true, 5899 }, { 5900 name: "HeadlessSelectorless_Policy:RequireDualStack_Families:v6", 5901 line: line(), 5902 svc: svctest.MakeService("foo", 5903 svctest.SetHeadless, 5904 svctest.SetSelector(nil), 5905 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 5906 svctest.SetIPFamilies(api.IPv6Protocol)), 5907 expectPolicy: api.IPFamilyPolicyRequireDualStack, 5908 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 5909 expectHeadless: true, 5910 }, { 5911 name: "HeadlessSelectorless_Policy:RequireDualStack_Families:v4v6", 5912 line: line(), 5913 svc: svctest.MakeService("foo", 5914 svctest.SetHeadless, 5915 svctest.SetSelector(nil), 5916 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 5917 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 5918 expectPolicy: api.IPFamilyPolicyRequireDualStack, 5919 expectFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 5920 expectHeadless: true, 5921 }, { 5922 name: "HeadlessSelectorless_Policy:RequireDualStack_Families:v6v4", 5923 line: line(), 5924 svc: svctest.MakeService("foo", 5925 svctest.SetHeadless, 5926 svctest.SetSelector(nil), 5927 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 5928 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 5929 expectPolicy: api.IPFamilyPolicyRequireDualStack, 5930 expectFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 5931 expectHeadless: true, 5932 }, 5933 }, 5934 }, 5935 } 5936 5937 for _, otc := range testCases { 5938 t.Run(otc.name, func(t *testing.T) { 5939 5940 // Do this in the outer loop for performance. 5941 storage, _, server := newStorage(t, otc.clusterFamilies) 5942 defer server.Terminate(t) 5943 defer storage.Store.DestroyFunc() 5944 5945 for _, itc := range otc.cases { 5946 t.Run(itc.name+"__@L"+itc.line, func(t *testing.T) { 5947 ctx := genericapirequest.NewDefaultContext() 5948 createdObj, err := storage.Create(ctx, itc.svc, rest.ValidateAllObjectFunc, &metav1.CreateOptions{}) 5949 if itc.expectError && err != nil { 5950 return 5951 } 5952 if err != nil { 5953 t.Fatalf("unexpected error creating service: %v", err) 5954 } 5955 defer storage.Delete(ctx, itc.svc.Name, rest.ValidateAllObjectFunc, &metav1.DeleteOptions{}) 5956 if itc.expectError && err == nil { 5957 t.Fatalf("unexpected success creating service") 5958 } 5959 createdSvc := createdObj.(*api.Service) 5960 5961 if want, got := fmtIPFamilyPolicy(&itc.expectPolicy), fmtIPFamilyPolicy(createdSvc.Spec.IPFamilyPolicy); want != got { 5962 t.Errorf("wrong IPFamilyPolicy: want %s, got %s", want, got) 5963 } 5964 if want, got := fmtIPFamilies(itc.expectFamilies), fmtIPFamilies(createdSvc.Spec.IPFamilies); want != got { 5965 t.Errorf("wrong IPFamilies: want %s, got %s", want, got) 5966 } 5967 if itc.expectHeadless { 5968 proveHeadless(t, storage, nil, createdSvc) 5969 return 5970 } 5971 proveClusterIPsAllocated(t, storage, nil, createdSvc) 5972 }) 5973 } 5974 }) 5975 } 5976 } 5977 5978 // There are enough corner-cases that it's useful to have a test that asserts 5979 // the errors. Some of these are in other tests, but this is clearer. 5980 func TestCreateInvalidClusterIPInputs(t *testing.T) { 5981 testCases := []struct { 5982 name string 5983 families []api.IPFamily 5984 svc *api.Service 5985 expect []string 5986 }{{ 5987 name: "bad_ipFamilyPolicy", 5988 families: []api.IPFamily{api.IPv4Protocol}, 5989 svc: svctest.MakeService("foo", 5990 svctest.SetIPFamilyPolicy(api.IPFamilyPolicy("garbage"))), 5991 expect: []string{"Unsupported value"}, 5992 }, { 5993 name: "requiredual_ipFamilyPolicy_on_singlestack", 5994 families: []api.IPFamily{api.IPv4Protocol}, 5995 svc: svctest.MakeService("foo", 5996 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack)), 5997 expect: []string{"cluster is not configured for dual-stack"}, 5998 }, { 5999 name: "bad_ipFamilies_0_value", 6000 families: []api.IPFamily{api.IPv4Protocol}, 6001 svc: svctest.MakeService("foo", 6002 svctest.SetIPFamilies(api.IPFamily("garbage"))), 6003 expect: []string{"Unsupported value"}, 6004 }, { 6005 name: "bad_ipFamilies_1_value", 6006 families: []api.IPFamily{api.IPv4Protocol}, 6007 svc: svctest.MakeService("foo", 6008 svctest.SetIPFamilies(api.IPv4Protocol, api.IPFamily("garbage"))), 6009 expect: []string{"Unsupported value"}, 6010 }, { 6011 name: "bad_ipFamilies_2_value", 6012 families: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 6013 svc: svctest.MakeService("foo", 6014 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol, api.IPFamily("garbage"))), 6015 expect: []string{"Unsupported value"}, 6016 }, { 6017 name: "wrong_ipFamily", 6018 families: []api.IPFamily{api.IPv4Protocol}, 6019 svc: svctest.MakeService("foo", 6020 svctest.SetIPFamilies(api.IPv6Protocol)), 6021 expect: []string{"not configured on this cluster"}, 6022 }, { 6023 name: "too_many_ipFamilies_on_singlestack", 6024 families: []api.IPFamily{api.IPv4Protocol}, 6025 svc: svctest.MakeService("foo", 6026 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 6027 expect: []string{"when multiple IP families are specified"}, 6028 }, { 6029 name: "dup_ipFamily_singlestack", 6030 families: []api.IPFamily{api.IPv4Protocol}, 6031 svc: svctest.MakeService("foo", 6032 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv4Protocol)), 6033 expect: []string{"Duplicate value"}, 6034 }, { 6035 name: "dup_ipFamily_dualstack", 6036 families: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 6037 svc: svctest.MakeService("foo", 6038 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol, api.IPv6Protocol)), 6039 expect: []string{"Duplicate value"}, 6040 }, { 6041 name: "bad_IP", 6042 families: []api.IPFamily{api.IPv4Protocol}, 6043 svc: svctest.MakeService("foo", 6044 svctest.SetClusterIPs("garbage")), 6045 expect: []string{"must be a valid IP"}, 6046 }, { 6047 name: "IP_wrong_family", 6048 families: []api.IPFamily{api.IPv4Protocol}, 6049 svc: svctest.MakeService("foo", 6050 svctest.SetClusterIPs("2000::1")), 6051 expect: []string{"not configured on this cluster"}, 6052 }, { 6053 name: "IP_doesnt_match_family", 6054 families: []api.IPFamily{api.IPv4Protocol}, 6055 svc: svctest.MakeService("foo", 6056 svctest.SetIPFamilies(api.IPv4Protocol), 6057 svctest.SetClusterIPs("2000::1")), 6058 expect: []string{"expected an IPv4 value as indicated"}, 6059 }, { 6060 name: "too_many_IPs_singlestack", 6061 families: []api.IPFamily{api.IPv4Protocol}, 6062 svc: svctest.MakeService("foo", 6063 svctest.SetClusterIPs("10.0.0.1", "10.0.0.2")), 6064 expect: []string{"no more than one IP for each IP family"}, 6065 }, { 6066 name: "too_many_IPs_dualstack", 6067 families: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 6068 svc: svctest.MakeService("foo", 6069 svctest.SetClusterIPs("10.0.0.1", "2000::1", "10.0.0.2")), 6070 expect: []string{"only hold up to 2 values"}, 6071 }, { 6072 name: "dup_IPs", 6073 families: []api.IPFamily{api.IPv4Protocol}, 6074 svc: svctest.MakeService("foo", 6075 svctest.SetClusterIPs("10.0.0.1", "10.0.0.1")), 6076 expect: []string{"no more than one IP for each IP family"}, 6077 }, { 6078 name: "empty_IP", 6079 families: []api.IPFamily{api.IPv4Protocol}, 6080 svc: svctest.MakeService("foo", 6081 svctest.SetClusterIPs("")), 6082 expect: []string{"must be empty when", "must be a valid IP"}, 6083 }, { 6084 name: "None_IP_1", 6085 families: []api.IPFamily{api.IPv4Protocol}, 6086 svc: svctest.MakeService("foo", 6087 svctest.SetClusterIPs("10.0.0.1", "None")), 6088 expect: []string{"must be a valid IP"}, 6089 }} 6090 6091 for _, tc := range testCases { 6092 t.Run(tc.name, func(t *testing.T) { 6093 storage, _, server := newStorage(t, tc.families) 6094 defer server.Terminate(t) 6095 defer storage.Store.DestroyFunc() 6096 6097 ctx := genericapirequest.NewDefaultContext() 6098 _, err := storage.Create(ctx, tc.svc, rest.ValidateAllObjectFunc, &metav1.CreateOptions{}) 6099 if err == nil { 6100 t.Fatalf("unexpected success creating service") 6101 } 6102 for _, s := range tc.expect { 6103 if !strings.Contains(err.Error(), s) { 6104 t.Errorf("expected to find %q in the error:\n %s", s, err.Error()) 6105 } 6106 } 6107 }) 6108 } 6109 } 6110 6111 func TestCreateDeleteReuse(t *testing.T) { 6112 testCases := []struct { 6113 name string 6114 svc *api.Service 6115 }{{ 6116 name: "v4", 6117 svc: svctest.MakeService("foo", svctest.SetTypeNodePort, 6118 svctest.SetIPFamilies(api.IPv4Protocol)), 6119 }, { 6120 name: "v6", 6121 svc: svctest.MakeService("foo", svctest.SetTypeNodePort, 6122 svctest.SetIPFamilies(api.IPv6Protocol)), 6123 }, { 6124 name: "v4v6", 6125 svc: svctest.MakeService("foo", svctest.SetTypeNodePort, 6126 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 6127 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 6128 }} 6129 6130 for _, tc := range testCases { 6131 t.Run(tc.name, func(t *testing.T) { 6132 storage, _, server := newStorage(t, []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}) 6133 defer server.Terminate(t) 6134 defer storage.Store.DestroyFunc() 6135 6136 ctx := genericapirequest.NewDefaultContext() 6137 6138 // Create it 6139 createdObj, err := storage.Create(ctx, tc.svc, rest.ValidateAllObjectFunc, &metav1.CreateOptions{}) 6140 if err != nil { 6141 t.Fatalf("unexpected error creating service: %v", err) 6142 } 6143 createdSvc := createdObj.(*api.Service) 6144 6145 // Ensure IPs and ports were allocated 6146 proveClusterIPsAllocated(t, storage, tc.svc, createdSvc) 6147 proveNodePortsAllocated(t, storage, tc.svc, createdSvc) 6148 6149 // Delete it 6150 _, _, err = storage.Delete(ctx, tc.svc.Name, rest.ValidateAllObjectFunc, &metav1.DeleteOptions{}) 6151 if err != nil { 6152 t.Fatalf("unexpected error creating service: %v", err) 6153 } 6154 6155 // Ensure IPs and ports were deallocated 6156 proveClusterIPsDeallocated(t, storage, createdSvc, nil) 6157 proveNodePortsDeallocated(t, storage, createdSvc, nil) 6158 6159 // Force the same IPs and ports 6160 svc2 := tc.svc.DeepCopy() 6161 svc2.Name += "2" 6162 svc2.Spec.ClusterIP = createdSvc.Spec.ClusterIP 6163 svc2.Spec.ClusterIPs = createdSvc.Spec.ClusterIPs 6164 svc2.Spec.Ports = createdSvc.Spec.Ports 6165 6166 // Create again 6167 _, err = storage.Create(ctx, svc2, rest.ValidateAllObjectFunc, &metav1.CreateOptions{}) 6168 if err != nil { 6169 t.Fatalf("unexpected error creating service: %v", err) 6170 } 6171 6172 // Ensure IPs and ports were allocated 6173 proveClusterIPsAllocated(t, storage, svc2, createdSvc) 6174 proveNodePortsAllocated(t, storage, svc2, createdSvc) 6175 }) 6176 } 6177 } 6178 6179 func TestCreateInitNodePorts(t *testing.T) { 6180 testCases := []struct { 6181 name string 6182 svc *api.Service 6183 expectError bool 6184 expectNodePorts bool 6185 }{{ 6186 name: "type:ExternalName", 6187 svc: svctest.MakeService("foo"), 6188 expectNodePorts: false, 6189 }, { 6190 name: "type:ExternalName_with_NodePorts", 6191 svc: svctest.MakeService("foo", 6192 svctest.SetUniqueNodePorts), 6193 expectError: true, 6194 }, { 6195 name: "type:ClusterIP", 6196 svc: svctest.MakeService("foo"), 6197 expectNodePorts: false, 6198 }, { 6199 name: "type:ClusterIP_with_NodePorts", 6200 svc: svctest.MakeService("foo", 6201 svctest.SetUniqueNodePorts), 6202 expectError: true, 6203 }, { 6204 name: "type:NodePort_single_port_unspecified", 6205 svc: svctest.MakeService("foo", 6206 svctest.SetTypeNodePort), 6207 expectNodePorts: true, 6208 }, { 6209 name: "type:NodePort_single_port_specified", 6210 svc: svctest.MakeService("foo", 6211 svctest.SetTypeNodePort, svctest.SetUniqueNodePorts), 6212 expectNodePorts: true, 6213 }, { 6214 name: "type:NodePort_multiport_unspecified", 6215 svc: svctest.MakeService("foo", 6216 svctest.SetTypeNodePort, 6217 svctest.SetPorts( 6218 svctest.MakeServicePort("p", 80, intstr.FromInt32(80), api.ProtocolTCP), 6219 svctest.MakeServicePort("q", 443, intstr.FromInt32(443), api.ProtocolTCP))), 6220 expectNodePorts: true, 6221 }, { 6222 name: "type:NodePort_multiport_specified", 6223 svc: svctest.MakeService("foo", 6224 svctest.SetTypeNodePort, 6225 svctest.SetPorts( 6226 svctest.MakeServicePort("p", 80, intstr.FromInt32(80), api.ProtocolTCP), 6227 svctest.MakeServicePort("q", 443, intstr.FromInt32(443), api.ProtocolTCP)), 6228 svctest.SetUniqueNodePorts), 6229 expectNodePorts: true, 6230 }, { 6231 name: "type:NodePort_multiport_same", 6232 svc: svctest.MakeService("foo", 6233 svctest.SetTypeNodePort, 6234 svctest.SetPorts( 6235 svctest.MakeServicePort("p", 80, intstr.FromInt32(80), api.ProtocolTCP), 6236 svctest.MakeServicePort("q", 443, intstr.FromInt32(443), api.ProtocolTCP)), 6237 svctest.SetNodePorts(30080, 30080)), 6238 expectError: true, 6239 }, { 6240 name: "type:NodePort_multiport_multiproto_unspecified", 6241 svc: svctest.MakeService("foo", 6242 svctest.SetTypeNodePort, 6243 svctest.SetPorts( 6244 svctest.MakeServicePort("p", 53, intstr.FromInt32(53), api.ProtocolTCP), 6245 svctest.MakeServicePort("q", 53, intstr.FromInt32(53), api.ProtocolUDP))), 6246 expectNodePorts: true, 6247 }, { 6248 name: "type:NodePort_multiport_multiproto_specified", 6249 svc: svctest.MakeService("foo", 6250 svctest.SetTypeNodePort, 6251 svctest.SetPorts( 6252 svctest.MakeServicePort("p", 53, intstr.FromInt32(53), api.ProtocolTCP), 6253 svctest.MakeServicePort("q", 53, intstr.FromInt32(53), api.ProtocolUDP)), 6254 svctest.SetUniqueNodePorts), 6255 expectNodePorts: true, 6256 }, { 6257 name: "type:NodePort_multiport_multiproto_same", 6258 svc: svctest.MakeService("foo", 6259 svctest.SetTypeNodePort, 6260 svctest.SetPorts( 6261 svctest.MakeServicePort("p", 53, intstr.FromInt32(53), api.ProtocolTCP), 6262 svctest.MakeServicePort("q", 53, intstr.FromInt32(53), api.ProtocolUDP)), 6263 svctest.SetNodePorts(30053, 30053)), 6264 expectNodePorts: true, 6265 }, { 6266 name: "type:NodePort_multiport_multiproto_conflict", 6267 svc: svctest.MakeService("foo", 6268 svctest.SetTypeNodePort, 6269 svctest.SetPorts( 6270 svctest.MakeServicePort("p", 93, intstr.FromInt32(93), api.ProtocolTCP), 6271 svctest.MakeServicePort("q", 76, intstr.FromInt32(76), api.ProtocolUDP)), 6272 svctest.SetNodePorts(30093, 30093)), 6273 expectError: true, 6274 }, { 6275 name: "type:LoadBalancer_single_port_unspecified:on_alloc:false", 6276 svc: svctest.MakeService("foo", 6277 svctest.SetTypeLoadBalancer, 6278 svctest.SetAllocateLoadBalancerNodePorts(false)), 6279 expectNodePorts: false, 6280 }, { 6281 name: "type:LoadBalancer_single_port_unspecified:on_alloc:true", 6282 svc: svctest.MakeService("foo", 6283 svctest.SetTypeLoadBalancer, 6284 svctest.SetAllocateLoadBalancerNodePorts(true)), 6285 expectNodePorts: true, 6286 }, { 6287 name: "type:LoadBalancer_single_port_specified:on_alloc:false", 6288 svc: svctest.MakeService("foo", 6289 svctest.SetTypeLoadBalancer, 6290 svctest.SetUniqueNodePorts, 6291 svctest.SetAllocateLoadBalancerNodePorts(false)), 6292 expectNodePorts: true, 6293 }, { 6294 name: "type:LoadBalancer_single_port_specified:on_alloc:true", 6295 svc: svctest.MakeService("foo", 6296 svctest.SetTypeLoadBalancer, 6297 svctest.SetUniqueNodePorts, 6298 svctest.SetAllocateLoadBalancerNodePorts(true)), 6299 expectNodePorts: true, 6300 }, { 6301 name: "type:LoadBalancer_multiport_unspecified:on_alloc:false", 6302 svc: svctest.MakeService("foo", 6303 svctest.SetTypeLoadBalancer, 6304 svctest.SetPorts( 6305 svctest.MakeServicePort("p", 80, intstr.FromInt32(80), api.ProtocolTCP), 6306 svctest.MakeServicePort("q", 443, intstr.FromInt32(443), api.ProtocolTCP)), 6307 svctest.SetAllocateLoadBalancerNodePorts(false)), 6308 expectNodePorts: false, 6309 }, { 6310 name: "type:LoadBalancer_multiport_unspecified:on_alloc:true", 6311 svc: svctest.MakeService("foo", 6312 svctest.SetTypeLoadBalancer, 6313 svctest.SetPorts( 6314 svctest.MakeServicePort("p", 80, intstr.FromInt32(80), api.ProtocolTCP), 6315 svctest.MakeServicePort("q", 443, intstr.FromInt32(443), api.ProtocolTCP)), 6316 svctest.SetAllocateLoadBalancerNodePorts(true)), 6317 expectNodePorts: true, 6318 }, { 6319 name: "type:LoadBalancer_multiport_specified:on_alloc:false", 6320 svc: svctest.MakeService("foo", 6321 svctest.SetTypeLoadBalancer, 6322 svctest.SetPorts( 6323 svctest.MakeServicePort("p", 80, intstr.FromInt32(80), api.ProtocolTCP), 6324 svctest.MakeServicePort("q", 443, intstr.FromInt32(443), api.ProtocolTCP)), 6325 svctest.SetUniqueNodePorts, 6326 svctest.SetAllocateLoadBalancerNodePorts(false)), 6327 expectNodePorts: true, 6328 }, { 6329 name: "type:LoadBalancer_multiport_specified:on_alloc:true", 6330 svc: svctest.MakeService("foo", 6331 svctest.SetTypeLoadBalancer, 6332 svctest.SetPorts( 6333 svctest.MakeServicePort("p", 80, intstr.FromInt32(80), api.ProtocolTCP), 6334 svctest.MakeServicePort("q", 443, intstr.FromInt32(443), api.ProtocolTCP)), 6335 svctest.SetUniqueNodePorts, 6336 svctest.SetAllocateLoadBalancerNodePorts(true)), 6337 expectNodePorts: true, 6338 }, { 6339 name: "type:LoadBalancer_multiport_same", 6340 svc: svctest.MakeService("foo", 6341 svctest.SetTypeLoadBalancer, 6342 svctest.SetPorts( 6343 svctest.MakeServicePort("p", 80, intstr.FromInt32(80), api.ProtocolTCP), 6344 svctest.MakeServicePort("q", 443, intstr.FromInt32(443), api.ProtocolTCP)), 6345 svctest.SetNodePorts(30080, 30080)), 6346 expectError: true, 6347 }, { 6348 name: "type:LoadBalancer_multiport_multiproto_unspecified", 6349 svc: svctest.MakeService("foo", 6350 svctest.SetTypeLoadBalancer, 6351 svctest.SetPorts( 6352 svctest.MakeServicePort("p", 53, intstr.FromInt32(53), api.ProtocolTCP), 6353 svctest.MakeServicePort("q", 53, intstr.FromInt32(53), api.ProtocolUDP))), 6354 expectNodePorts: true, 6355 }, { 6356 name: "type:LoadBalancer_multiport_multiproto_specified", 6357 svc: svctest.MakeService("foo", 6358 svctest.SetTypeLoadBalancer, 6359 svctest.SetPorts( 6360 svctest.MakeServicePort("p", 53, intstr.FromInt32(53), api.ProtocolTCP), 6361 svctest.MakeServicePort("q", 53, intstr.FromInt32(53), api.ProtocolUDP)), 6362 svctest.SetUniqueNodePorts), 6363 expectNodePorts: true, 6364 }, { 6365 name: "type:LoadBalancer_multiport_multiproto_same", 6366 svc: svctest.MakeService("foo", 6367 svctest.SetTypeLoadBalancer, 6368 svctest.SetPorts( 6369 svctest.MakeServicePort("p", 53, intstr.FromInt32(53), api.ProtocolTCP), 6370 svctest.MakeServicePort("q", 53, intstr.FromInt32(53), api.ProtocolUDP)), 6371 svctest.SetNodePorts(30053, 30053)), 6372 expectNodePorts: true, 6373 }, { 6374 name: "type:LoadBalancer_multiport_multiproto_conflict", 6375 svc: svctest.MakeService("foo", 6376 svctest.SetTypeLoadBalancer, 6377 svctest.SetPorts( 6378 svctest.MakeServicePort("p", 93, intstr.FromInt32(93), api.ProtocolTCP), 6379 svctest.MakeServicePort("q", 76, intstr.FromInt32(76), api.ProtocolUDP)), 6380 svctest.SetNodePorts(30093, 30093)), 6381 expectError: true, 6382 }} 6383 6384 // Do this in the outer scope for performance. 6385 storage, _, server := newStorage(t, []api.IPFamily{api.IPv4Protocol}) 6386 defer server.Terminate(t) 6387 defer storage.Store.DestroyFunc() 6388 6389 for _, tc := range testCases { 6390 t.Run(tc.name, func(t *testing.T) { 6391 ctx := genericapirequest.NewDefaultContext() 6392 createdObj, err := storage.Create(ctx, tc.svc, rest.ValidateAllObjectFunc, &metav1.CreateOptions{}) 6393 if tc.expectError && err != nil { 6394 return 6395 } 6396 if err != nil { 6397 t.Fatalf("unexpected error creating service: %v", err) 6398 } 6399 defer storage.Delete(ctx, tc.svc.Name, rest.ValidateAllObjectFunc, &metav1.DeleteOptions{}) 6400 if tc.expectError && err == nil { 6401 t.Fatalf("unexpected success creating service") 6402 } 6403 createdSvc := createdObj.(*api.Service) 6404 6405 // Produce a map of port index to nodeport value, excluding zero. 6406 ports := map[int]*api.ServicePort{} 6407 for i := range createdSvc.Spec.Ports { 6408 p := &createdSvc.Spec.Ports[i] 6409 if p.NodePort != 0 { 6410 ports[i] = p 6411 } 6412 } 6413 6414 if tc.expectNodePorts && len(ports) == 0 { 6415 t.Fatalf("expected NodePorts to be allocated, found none") 6416 } 6417 if !tc.expectNodePorts && len(ports) > 0 { 6418 t.Fatalf("expected NodePorts to not be allocated, found %v", ports) 6419 } 6420 if !tc.expectNodePorts { 6421 return 6422 } 6423 6424 // Make sure we got the right number of allocations 6425 if want, got := len(ports), len(tc.svc.Spec.Ports); want != got { 6426 t.Fatalf("expected %d NodePorts, found %d", want, got) 6427 } 6428 6429 // Make sure they are all allocated 6430 for _, p := range ports { 6431 if !portIsAllocated(t, storage.alloc.serviceNodePorts, p.NodePort) { 6432 t.Errorf("expected port to be allocated: %v", p) 6433 } 6434 } 6435 6436 // Make sure we got any specific allocations 6437 for i, p := range tc.svc.Spec.Ports { 6438 if p.NodePort != 0 { 6439 if ports[i].NodePort != p.NodePort { 6440 t.Errorf("expected Ports[%d].NodePort to be %d, got %d", i, p.NodePort, ports[i].NodePort) 6441 } 6442 // Remove requested ports from the set 6443 delete(ports, i) 6444 } 6445 } 6446 6447 // Make sure any allocated ports are unique 6448 seen := map[int32]int32{} 6449 for i, p := range ports { 6450 // We allow the same NodePort for different protocols of the 6451 // same Port. 6452 if prev, found := seen[p.NodePort]; found && prev != p.Port { 6453 t.Errorf("found non-unique allocation in Ports[%d].NodePort: %d -> %d", i, p.NodePort, p.Port) 6454 } 6455 seen[p.NodePort] = p.Port 6456 } 6457 }) 6458 } 6459 } 6460 6461 // Prove that create skips allocations for Headless services. 6462 func TestCreateSkipsAllocationsForHeadless(t *testing.T) { 6463 testCases := []struct { 6464 name string 6465 clusterFamilies []api.IPFamily 6466 svc *api.Service 6467 expectError bool 6468 }{{ 6469 name: "singlestack:v4", 6470 clusterFamilies: []api.IPFamily{api.IPv4Protocol}, 6471 svc: svctest.MakeService("foo"), 6472 }, { 6473 name: "singlestack:v6", 6474 clusterFamilies: []api.IPFamily{api.IPv6Protocol}, 6475 svc: svctest.MakeService("foo"), 6476 }, { 6477 name: "dualstack:v4v6", 6478 clusterFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 6479 svc: svctest.MakeService("foo"), 6480 }, { 6481 name: "dualstack:v6v4", 6482 clusterFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 6483 svc: svctest.MakeService("foo"), 6484 }, { 6485 name: "singlestack:v4_type:NodePort", 6486 clusterFamilies: []api.IPFamily{api.IPv4Protocol}, 6487 svc: svctest.MakeService("foo", svctest.SetTypeNodePort), 6488 expectError: true, 6489 }, { 6490 name: "singlestack:v6_type:LoadBalancer", 6491 clusterFamilies: []api.IPFamily{api.IPv6Protocol}, 6492 svc: svctest.MakeService("foo", svctest.SetTypeLoadBalancer), 6493 expectError: true, 6494 }} 6495 6496 for _, tc := range testCases { 6497 t.Run(tc.name, func(t *testing.T) { 6498 storage, _, server := newStorage(t, tc.clusterFamilies) 6499 defer server.Terminate(t) 6500 defer storage.Store.DestroyFunc() 6501 6502 // This test is ONLY headless services. 6503 tc.svc.Spec.ClusterIP = api.ClusterIPNone 6504 6505 ctx := genericapirequest.NewDefaultContext() 6506 createdObj, err := storage.Create(ctx, tc.svc, rest.ValidateAllObjectFunc, &metav1.CreateOptions{}) 6507 if tc.expectError && err != nil { 6508 return 6509 } 6510 if err != nil { 6511 t.Fatalf("unexpected error creating service: %v", err) 6512 } 6513 if tc.expectError && err == nil { 6514 t.Fatalf("unexpected success creating service") 6515 } 6516 createdSvc := createdObj.(*api.Service) 6517 6518 if createdSvc.Spec.ClusterIP != "None" { 6519 t.Errorf("expected clusterIP \"None\", got %q", createdSvc.Spec.ClusterIP) 6520 } 6521 if !reflect.DeepEqual(createdSvc.Spec.ClusterIPs, []string{"None"}) { 6522 t.Errorf("expected clusterIPs [\"None\"], got %q", createdSvc.Spec.ClusterIPs) 6523 } 6524 }) 6525 } 6526 } 6527 6528 // Prove that a dry-run create doesn't actually allocate IPs or ports. 6529 func TestCreateDryRun(t *testing.T) { 6530 testCases := []struct { 6531 name string 6532 clusterFamilies []api.IPFamily 6533 svc *api.Service 6534 }{{ 6535 name: "singlestack:v4_clusterip:unset", 6536 clusterFamilies: []api.IPFamily{api.IPv4Protocol}, 6537 svc: svctest.MakeService("foo"), 6538 }, { 6539 name: "singlestack:v4_clusterip:set", 6540 clusterFamilies: []api.IPFamily{api.IPv4Protocol}, 6541 svc: svctest.MakeService("foo", svctest.SetClusterIPs("10.0.0.1")), 6542 }, { 6543 name: "singlestack:v6_clusterip:unset", 6544 clusterFamilies: []api.IPFamily{api.IPv6Protocol}, 6545 svc: svctest.MakeService("foo"), 6546 }, { 6547 name: "singlestack:v6_clusterip:set", 6548 clusterFamilies: []api.IPFamily{api.IPv6Protocol}, 6549 svc: svctest.MakeService("foo", svctest.SetClusterIPs("2000::1")), 6550 }, { 6551 name: "dualstack:v4v6_clusterip:unset", 6552 clusterFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 6553 svc: svctest.MakeService("foo", svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack)), 6554 }, { 6555 name: "dualstack:v4v6_clusterip:set", 6556 clusterFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 6557 svc: svctest.MakeService("foo", svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), svctest.SetClusterIPs("10.0.0.1", "2000::1")), 6558 }, { 6559 name: "singlestack:v4_type:NodePort_nodeport:unset", 6560 clusterFamilies: []api.IPFamily{api.IPv4Protocol}, 6561 svc: svctest.MakeService("foo", svctest.SetTypeNodePort), 6562 }, { 6563 name: "singlestack:v4_type:LoadBalancer_nodePort:set", 6564 clusterFamilies: []api.IPFamily{api.IPv4Protocol}, 6565 svc: svctest.MakeService("foo", svctest.SetTypeLoadBalancer, svctest.SetUniqueNodePorts), 6566 }} 6567 6568 for _, tc := range testCases { 6569 t.Run(tc.name, func(t *testing.T) { 6570 storage, _, server := newStorage(t, tc.clusterFamilies) 6571 defer server.Terminate(t) 6572 defer storage.Store.DestroyFunc() 6573 6574 ctx := genericapirequest.NewDefaultContext() 6575 createdObj, err := storage.Create(ctx, tc.svc, rest.ValidateAllObjectFunc, &metav1.CreateOptions{DryRun: []string{metav1.DryRunAll}}) 6576 if err != nil { 6577 t.Fatalf("unexpected error creating service: %v", err) 6578 } 6579 createdSvc := createdObj.(*api.Service) 6580 6581 // Ensure IPs were assigned 6582 if netutils.ParseIPSloppy(createdSvc.Spec.ClusterIP) == nil { 6583 t.Errorf("expected valid clusterIP: %q", createdSvc.Spec.ClusterIP) 6584 } 6585 for _, ip := range createdSvc.Spec.ClusterIPs { 6586 if netutils.ParseIPSloppy(ip) == nil { 6587 t.Errorf("expected valid clusterIP: %q", createdSvc.Spec.ClusterIP) 6588 } 6589 } 6590 6591 // Ensure the allocators are clean. 6592 proveClusterIPsDeallocated(t, storage, createdSvc, nil) 6593 if tc.svc.Spec.Type != api.ServiceTypeClusterIP { 6594 proveNodePortsDeallocated(t, storage, createdSvc, nil) 6595 } 6596 }) 6597 } 6598 } 6599 6600 func TestDeleteWithFinalizer(t *testing.T) { 6601 svcName := "foo" 6602 6603 storage, _, server := newStorage(t, []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}) 6604 defer server.Terminate(t) 6605 defer storage.Store.DestroyFunc() 6606 6607 // This will allocate cluster IPs, NodePort, and HealthCheckNodePort. 6608 svc := svctest.MakeService(svcName, svctest.SetTypeLoadBalancer, 6609 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal), 6610 func(s *api.Service) { 6611 s.Finalizers = []string{"example.com/test"} 6612 }) 6613 6614 ctx := genericapirequest.NewDefaultContext() 6615 6616 // Create it with finalizer. 6617 obj, err := storage.Create(ctx, svc, rest.ValidateAllObjectFunc, &metav1.CreateOptions{}) 6618 if err != nil { 6619 t.Fatalf("unexpected error creating service: %v", err) 6620 } 6621 createdSvc := obj.(*api.Service) 6622 6623 // Prove everything was allocated. 6624 obj, err = storage.Get(ctx, svcName, &metav1.GetOptions{}) 6625 if err != nil { 6626 t.Fatalf("unexpected error getting service: %v", err) 6627 } 6628 if !cmp.Equal(createdSvc, obj) { 6629 t.Errorf("expected the result of Create() and Get() to match: %v", cmp.Diff(createdSvc, obj)) 6630 } 6631 proveClusterIPsAllocated(t, storage, svc, createdSvc) 6632 proveNodePortsAllocated(t, storage, svc, createdSvc) 6633 proveHealthCheckNodePortAllocated(t, storage, svc, createdSvc) 6634 6635 // Try to delete it, but it should be blocked by the finalizer. 6636 obj, deleted, err := storage.Delete(ctx, svcName, rest.ValidateAllObjectFunc, &metav1.DeleteOptions{}) 6637 if err != nil { 6638 t.Fatalf("unexpected error deleting service: %v", err) 6639 } 6640 if deleted { 6641 t.Fatalf("expected service to not be deleted") 6642 } 6643 deletedSvc := obj.(*api.Service) 6644 6645 // Prove everything is still allocated. 6646 _, err = storage.Get(ctx, svcName, &metav1.GetOptions{}) 6647 if err != nil { 6648 t.Fatalf("unexpected error getting service: %v", err) 6649 } 6650 proveClusterIPsAllocated(t, storage, svc, createdSvc) 6651 proveNodePortsAllocated(t, storage, svc, createdSvc) 6652 proveHealthCheckNodePortAllocated(t, storage, svc, createdSvc) 6653 6654 // Clear the finalizer - should delete. 6655 deletedSvc.Finalizers = nil 6656 _, _, err = storage.Update(ctx, svcName, 6657 rest.DefaultUpdatedObjectInfo(deletedSvc), rest.ValidateAllObjectFunc, 6658 rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{}) 6659 if err != nil { 6660 t.Fatalf("unexpected error updating service: %v", err) 6661 } 6662 6663 // Prove everything is deallocated. 6664 _, err = storage.Get(ctx, svcName, &metav1.GetOptions{}) 6665 if err == nil { 6666 t.Fatalf("unexpected success getting service") 6667 } 6668 proveClusterIPsDeallocated(t, storage, createdSvc, nil) 6669 proveNodePortsDeallocated(t, storage, createdSvc, nil) 6670 proveHealthCheckNodePortDeallocated(t, storage, createdSvc, nil) 6671 } 6672 6673 // Prove that a dry-run delete doesn't actually deallocate IPs or ports. 6674 func TestDeleteDryRun(t *testing.T) { 6675 testCases := []struct { 6676 name string 6677 svc *api.Service 6678 }{ 6679 { 6680 name: "v4", 6681 svc: svctest.MakeService("foo", 6682 svctest.SetTypeLoadBalancer, 6683 svctest.SetIPFamilies(api.IPv4Protocol), 6684 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal)), 6685 }, 6686 { 6687 name: "v4v6", 6688 svc: svctest.MakeService("foo", 6689 svctest.SetTypeLoadBalancer, 6690 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 6691 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol), 6692 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal)), 6693 }} 6694 6695 for _, tc := range testCases { 6696 t.Run(tc.name, func(t *testing.T) { 6697 6698 storage, _, server := newStorage(t, tc.svc.Spec.IPFamilies) 6699 defer server.Terminate(t) 6700 defer storage.Store.DestroyFunc() 6701 6702 ctx := genericapirequest.NewDefaultContext() 6703 createdObj, err := storage.Create(ctx, tc.svc, rest.ValidateAllObjectFunc, &metav1.CreateOptions{}) 6704 if err != nil { 6705 t.Fatalf("unexpected error creating service: %v", err) 6706 } 6707 createdSvc := createdObj.(*api.Service) 6708 6709 // Ensure IPs and ports were allocated 6710 proveClusterIPsAllocated(t, storage, tc.svc, createdSvc) 6711 proveNodePortsAllocated(t, storage, tc.svc, createdSvc) 6712 proveHealthCheckNodePortAllocated(t, storage, tc.svc, createdSvc) 6713 6714 _, _, err = storage.Delete(ctx, tc.svc.Name, rest.ValidateAllObjectFunc, &metav1.DeleteOptions{DryRun: []string{metav1.DryRunAll}}) 6715 if err != nil { 6716 t.Fatalf("unexpected error deleting service: %v", err) 6717 } 6718 6719 // Ensure they are still allocated. 6720 proveClusterIPsAllocated(t, storage, tc.svc, createdSvc) 6721 proveNodePortsAllocated(t, storage, tc.svc, createdSvc) 6722 proveHealthCheckNodePortAllocated(t, storage, tc.svc, createdSvc) 6723 }) 6724 } 6725 } 6726 6727 // Prove that a dry-run update doesn't actually allocate or deallocate IPs or ports. 6728 func TestUpdateDryRun(t *testing.T) { 6729 testCases := []struct { 6730 name string 6731 clusterFamilies []api.IPFamily 6732 svc *api.Service 6733 update *api.Service 6734 verifyDryAllocs bool 6735 }{{ 6736 name: "singlestack:v4_NoAllocs-Allocs", 6737 clusterFamilies: []api.IPFamily{api.IPv4Protocol}, 6738 svc: svctest.MakeService("foo", svctest.SetTypeExternalName), 6739 update: svctest.MakeService("foo", svctest.SetTypeLoadBalancer, 6740 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal)), 6741 verifyDryAllocs: true, // make sure values were not allocated. 6742 }, { 6743 name: "singlestack:v4_Allocs-NoAllocs", 6744 clusterFamilies: []api.IPFamily{api.IPv4Protocol}, 6745 svc: svctest.MakeService("foo", svctest.SetTypeLoadBalancer, 6746 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal)), 6747 update: svctest.MakeService("foo", svctest.SetTypeExternalName), 6748 verifyDryAllocs: false, // make sure values were not released. 6749 }, { 6750 name: "singlestack:v6_NoAllocs-Allocs", 6751 clusterFamilies: []api.IPFamily{api.IPv6Protocol}, 6752 svc: svctest.MakeService("foo", svctest.SetTypeExternalName), 6753 update: svctest.MakeService("foo", svctest.SetTypeLoadBalancer, 6754 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal)), 6755 verifyDryAllocs: true, // make sure values were not allocated. 6756 }, { 6757 name: "singlestack:v6_Allocs-NoAllocs", 6758 clusterFamilies: []api.IPFamily{api.IPv6Protocol}, 6759 svc: svctest.MakeService("foo", svctest.SetTypeLoadBalancer, 6760 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal)), 6761 update: svctest.MakeService("foo", svctest.SetTypeExternalName), 6762 verifyDryAllocs: false, // make sure values were not released. 6763 }, { 6764 name: "dualstack:v4v6_NoAllocs-Allocs", 6765 clusterFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 6766 svc: svctest.MakeService("foo", svctest.SetTypeExternalName), 6767 update: svctest.MakeService("foo", svctest.SetTypeLoadBalancer, 6768 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal)), 6769 verifyDryAllocs: true, // make sure values were not allocated. 6770 }, { 6771 name: "dualstack:v4v6_Allocs-NoAllocs", 6772 clusterFamilies: []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}, 6773 svc: svctest.MakeService("foo", svctest.SetTypeLoadBalancer, 6774 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal)), 6775 update: svctest.MakeService("foo", svctest.SetTypeExternalName), 6776 verifyDryAllocs: false, // make sure values were not released. 6777 }, { 6778 name: "dualstack:v6v4_NoAllocs-Allocs", 6779 clusterFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 6780 svc: svctest.MakeService("foo", svctest.SetTypeExternalName), 6781 update: svctest.MakeService("foo", svctest.SetTypeLoadBalancer, 6782 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal)), 6783 verifyDryAllocs: true, // make sure values were not allocated. 6784 }, { 6785 name: "dualstack:v6v4_Allocs-NoAllocs", 6786 clusterFamilies: []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}, 6787 svc: svctest.MakeService("foo", svctest.SetTypeLoadBalancer, 6788 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal)), 6789 update: svctest.MakeService("foo", svctest.SetTypeExternalName), 6790 verifyDryAllocs: false, // make sure values were not released. 6791 }} 6792 6793 for _, tc := range testCases { 6794 t.Run(tc.name, func(t *testing.T) { 6795 storage, _, server := newStorage(t, tc.clusterFamilies) 6796 defer server.Terminate(t) 6797 defer storage.Store.DestroyFunc() 6798 6799 ctx := genericapirequest.NewDefaultContext() 6800 obj, err := storage.Create(ctx, tc.svc, rest.ValidateAllObjectFunc, &metav1.CreateOptions{}) 6801 if err != nil { 6802 t.Fatalf("unexpected error creating service: %v", err) 6803 } 6804 createdSvc := obj.(*api.Service) 6805 6806 if tc.verifyDryAllocs { 6807 // Dry allocs means no allocs on create. Ensure values were 6808 // NOT allocated. 6809 proveClusterIPsDeallocated(t, storage, nil, createdSvc) 6810 } else { 6811 // Ensure IPs were allocated 6812 proveClusterIPsAllocated(t, storage, nil, createdSvc) 6813 } 6814 6815 // Update the object to the new state and check the results. 6816 obj, _, err = storage.Update(ctx, tc.update.Name, 6817 rest.DefaultUpdatedObjectInfo(tc.update), rest.ValidateAllObjectFunc, 6818 rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{DryRun: []string{metav1.DryRunAll}}) 6819 if err != nil { 6820 t.Fatalf("unexpected error updating service: %v", err) 6821 } 6822 updatedSvc := obj.(*api.Service) 6823 6824 if tc.verifyDryAllocs { 6825 // Dry allocs means the values are assigned but not 6826 // allocated. 6827 if netutils.ParseIPSloppy(updatedSvc.Spec.ClusterIP) == nil { 6828 t.Errorf("expected valid clusterIP: %q", updatedSvc.Spec.ClusterIP) 6829 } 6830 for _, ip := range updatedSvc.Spec.ClusterIPs { 6831 if netutils.ParseIPSloppy(ip) == nil { 6832 t.Errorf("expected valid clusterIP: %q", updatedSvc.Spec.ClusterIP) 6833 } 6834 } 6835 for i, fam := range updatedSvc.Spec.IPFamilies { 6836 if ipIsAllocated(t, storage.alloc.serviceIPAllocatorsByFamily[fam], updatedSvc.Spec.ClusterIPs[i]) { 6837 t.Errorf("expected IP to not be allocated: %q", updatedSvc.Spec.ClusterIPs[i]) 6838 } 6839 } 6840 6841 for _, p := range updatedSvc.Spec.Ports { 6842 if p.NodePort == 0 { 6843 t.Errorf("expected nodePort to be assigned: %d", p.NodePort) 6844 } 6845 if portIsAllocated(t, storage.alloc.serviceNodePorts, p.NodePort) { 6846 t.Errorf("expected nodePort to not be allocated: %d", p.NodePort) 6847 } 6848 } 6849 6850 if updatedSvc.Spec.HealthCheckNodePort == 0 { 6851 t.Errorf("expected HCNP to be assigned: %d", updatedSvc.Spec.HealthCheckNodePort) 6852 } 6853 if portIsAllocated(t, storage.alloc.serviceNodePorts, updatedSvc.Spec.HealthCheckNodePort) { 6854 t.Errorf("expected HCNP to not be allocated: %d", updatedSvc.Spec.HealthCheckNodePort) 6855 } 6856 } else { 6857 // Ensure IPs were unassigned but not deallocated. 6858 if updatedSvc.Spec.ClusterIP != "" { 6859 t.Errorf("expected clusterIP to be unset: %q", updatedSvc.Spec.ClusterIP) 6860 } 6861 if len(updatedSvc.Spec.ClusterIPs) != 0 { 6862 t.Errorf("expected clusterIPs to be unset: %q", updatedSvc.Spec.ClusterIPs) 6863 } 6864 for i, fam := range createdSvc.Spec.IPFamilies { 6865 if !ipIsAllocated(t, storage.alloc.serviceIPAllocatorsByFamily[fam], createdSvc.Spec.ClusterIPs[i]) { 6866 t.Errorf("expected IP to still be allocated: %q", createdSvc.Spec.ClusterIPs[i]) 6867 } 6868 } 6869 6870 for _, p := range updatedSvc.Spec.Ports { 6871 if p.NodePort != 0 { 6872 t.Errorf("expected nodePort to be unset: %d", p.NodePort) 6873 } 6874 } 6875 for _, p := range createdSvc.Spec.Ports { 6876 if !portIsAllocated(t, storage.alloc.serviceNodePorts, p.NodePort) { 6877 t.Errorf("expected nodePort to still be allocated: %d", p.NodePort) 6878 } 6879 } 6880 6881 if updatedSvc.Spec.HealthCheckNodePort != 0 { 6882 t.Errorf("expected HCNP to be unset: %d", updatedSvc.Spec.HealthCheckNodePort) 6883 } 6884 if !portIsAllocated(t, storage.alloc.serviceNodePorts, createdSvc.Spec.HealthCheckNodePort) { 6885 t.Errorf("expected HCNP to still be allocated: %d", createdSvc.Spec.HealthCheckNodePort) 6886 } 6887 } 6888 }) 6889 } 6890 } 6891 6892 func TestUpdatePatchAllocatedValues(t *testing.T) { 6893 prove := func(proofs ...svcTestProof) []svcTestProof { 6894 return proofs 6895 } 6896 proveClusterIP := func(idx int, ip string) svcTestProof { 6897 return func(t *testing.T, storage *wrapperRESTForTests, before, after *api.Service) { 6898 if want, got := ip, after.Spec.ClusterIPs[idx]; want != got { 6899 t.Errorf("wrong ClusterIPs[%d]: want %q, got %q", idx, want, got) 6900 } 6901 } 6902 } 6903 proveNodePort := func(idx int, port int32) svcTestProof { 6904 return func(t *testing.T, storage *wrapperRESTForTests, before, after *api.Service) { 6905 got := after.Spec.Ports[idx].NodePort 6906 if port > 0 && got != port { 6907 t.Errorf("wrong Ports[%d].NodePort: want %d, got %d", idx, port, got) 6908 } else if port < 0 && got == -port { 6909 t.Errorf("wrong Ports[%d].NodePort: wanted anything but %d", idx, got) 6910 } 6911 } 6912 } 6913 proveHCNP := func(port int32) svcTestProof { 6914 return func(t *testing.T, storage *wrapperRESTForTests, before, after *api.Service) { 6915 got := after.Spec.HealthCheckNodePort 6916 if port > 0 && got != port { 6917 t.Errorf("wrong HealthCheckNodePort: want %d, got %d", port, got) 6918 } else if port < 0 && got == -port { 6919 t.Errorf("wrong HealthCheckNodePort: wanted anything but %d", got) 6920 } 6921 } 6922 } 6923 6924 // each create needs clusterIP, NodePort, and HealthCheckNodePort allocated 6925 // each update needs clusterIP, NodePort, and/or HealthCheckNodePort blank 6926 testCases := []cudTestCase{{ 6927 name: "single-ip_single-port", 6928 create: svcTestCase{ 6929 svc: svctest.MakeService("foo", 6930 svctest.SetTypeLoadBalancer, 6931 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal), 6932 svctest.SetClusterIPs("10.0.0.1"), 6933 svctest.SetNodePorts(30093), 6934 svctest.SetHealthCheckNodePort(30118)), 6935 expectClusterIPs: true, 6936 expectNodePorts: true, 6937 expectHealthCheckNodePort: true, 6938 }, 6939 update: svcTestCase{ 6940 svc: svctest.MakeService("foo", 6941 svctest.SetTypeLoadBalancer, 6942 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal)), 6943 expectClusterIPs: true, 6944 expectNodePorts: true, 6945 expectHealthCheckNodePort: true, 6946 prove: prove( 6947 proveClusterIP(0, "10.0.0.1"), 6948 proveNodePort(0, 30093), 6949 proveHCNP(30118)), 6950 }, 6951 }, { 6952 name: "multi-ip_multi-port", 6953 create: svcTestCase{ 6954 svc: svctest.MakeService("foo", 6955 svctest.SetTypeLoadBalancer, 6956 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal), 6957 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 6958 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 6959 svctest.SetPorts( 6960 svctest.MakeServicePort("p", 867, intstr.FromInt32(867), api.ProtocolTCP), 6961 svctest.MakeServicePort("q", 5309, intstr.FromInt32(5309), api.ProtocolTCP)), 6962 svctest.SetNodePorts(30093, 30076), 6963 svctest.SetHealthCheckNodePort(30118)), 6964 expectClusterIPs: true, 6965 expectNodePorts: true, 6966 expectHealthCheckNodePort: true, 6967 }, 6968 update: svcTestCase{ 6969 svc: svctest.MakeService("foo", 6970 svctest.SetTypeLoadBalancer, 6971 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal), 6972 svctest.SetPorts( 6973 svctest.MakeServicePort("p", 867, intstr.FromInt32(867), api.ProtocolTCP), 6974 svctest.MakeServicePort("q", 5309, intstr.FromInt32(5309), api.ProtocolTCP))), 6975 expectClusterIPs: true, 6976 expectNodePorts: true, 6977 expectHealthCheckNodePort: true, 6978 prove: prove( 6979 proveClusterIP(0, "10.0.0.1"), 6980 proveClusterIP(1, "2000::1"), 6981 proveNodePort(0, 30093), 6982 proveNodePort(1, 30076), 6983 proveHCNP(30118)), 6984 }, 6985 }, { 6986 name: "multi-ip_partial", 6987 create: svcTestCase{ 6988 svc: svctest.MakeService("foo", 6989 svctest.SetTypeLoadBalancer, 6990 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal), 6991 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 6992 svctest.SetClusterIPs("10.0.0.1", "2000::1"), 6993 svctest.SetPorts( 6994 svctest.MakeServicePort("p", 867, intstr.FromInt32(867), api.ProtocolTCP), 6995 svctest.MakeServicePort("q", 5309, intstr.FromInt32(5309), api.ProtocolTCP)), 6996 svctest.SetNodePorts(30093, 30076), 6997 svctest.SetHealthCheckNodePort(30118)), 6998 expectClusterIPs: true, 6999 expectNodePorts: true, 7000 expectHealthCheckNodePort: true, 7001 }, 7002 update: svcTestCase{ 7003 svc: svctest.MakeService("foo", 7004 svctest.SetTypeLoadBalancer, 7005 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal), 7006 svctest.SetClusterIPs("10.0.0.1")), 7007 expectError: true, 7008 }, 7009 }, { 7010 name: "multi-port_partial", 7011 create: svcTestCase{ 7012 svc: svctest.MakeService("foo", 7013 svctest.SetTypeLoadBalancer, 7014 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal), 7015 svctest.SetPorts( 7016 svctest.MakeServicePort("p", 867, intstr.FromInt32(867), api.ProtocolTCP), 7017 svctest.MakeServicePort("q", 5309, intstr.FromInt32(5309), api.ProtocolTCP)), 7018 svctest.SetNodePorts(30093, 30076), 7019 svctest.SetHealthCheckNodePort(30118)), 7020 expectClusterIPs: true, 7021 expectNodePorts: true, 7022 expectHealthCheckNodePort: true, 7023 }, 7024 update: svcTestCase{ 7025 svc: svctest.MakeService("foo", 7026 svctest.SetTypeLoadBalancer, 7027 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal), 7028 svctest.SetPorts( 7029 svctest.MakeServicePort("p", 867, intstr.FromInt32(867), api.ProtocolTCP), 7030 svctest.MakeServicePort("q", 5309, intstr.FromInt32(5309), api.ProtocolTCP)), 7031 svctest.SetNodePorts(30093, 0)), // provide just 1 value 7032 expectClusterIPs: true, 7033 expectNodePorts: true, 7034 expectHealthCheckNodePort: true, 7035 prove: prove( 7036 proveNodePort(0, 30093), 7037 proveNodePort(1, 30076), 7038 proveHCNP(30118)), 7039 }, 7040 }, { 7041 name: "swap-ports", 7042 create: svcTestCase{ 7043 svc: svctest.MakeService("foo", 7044 svctest.SetTypeLoadBalancer, 7045 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal), 7046 svctest.SetPorts( 7047 svctest.MakeServicePort("p", 867, intstr.FromInt32(867), api.ProtocolTCP), 7048 svctest.MakeServicePort("q", 5309, intstr.FromInt32(5309), api.ProtocolTCP)), 7049 svctest.SetNodePorts(30093, 30076), 7050 svctest.SetHealthCheckNodePort(30118)), 7051 expectClusterIPs: true, 7052 expectNodePorts: true, 7053 expectHealthCheckNodePort: true, 7054 }, 7055 update: svcTestCase{ 7056 svc: svctest.MakeService("foo", 7057 svctest.SetTypeLoadBalancer, 7058 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal), 7059 svctest.SetPorts( 7060 // swapped from above 7061 svctest.MakeServicePort("q", 5309, intstr.FromInt32(5309), api.ProtocolTCP), 7062 svctest.MakeServicePort("p", 867, intstr.FromInt32(867), api.ProtocolTCP))), 7063 expectClusterIPs: true, 7064 expectNodePorts: true, 7065 expectHealthCheckNodePort: true, 7066 prove: prove( 7067 proveNodePort(0, 30076), 7068 proveNodePort(1, 30093), 7069 proveHCNP(30118)), 7070 }, 7071 }, { 7072 name: "partial-swap-ports", 7073 create: svcTestCase{ 7074 svc: svctest.MakeService("foo", 7075 svctest.SetTypeLoadBalancer, 7076 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal), 7077 svctest.SetPorts( 7078 svctest.MakeServicePort("p", 867, intstr.FromInt32(867), api.ProtocolTCP), 7079 svctest.MakeServicePort("q", 5309, intstr.FromInt32(5309), api.ProtocolTCP)), 7080 svctest.SetNodePorts(30093, 30076), 7081 svctest.SetHealthCheckNodePort(30118)), 7082 expectClusterIPs: true, 7083 expectNodePorts: true, 7084 expectHealthCheckNodePort: true, 7085 }, 7086 update: svcTestCase{ 7087 svc: svctest.MakeService("foo", 7088 svctest.SetTypeLoadBalancer, 7089 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal), 7090 svctest.SetPorts( 7091 svctest.MakeServicePort("p", 867, intstr.FromInt32(867), api.ProtocolTCP), 7092 svctest.MakeServicePort("q", 5309, intstr.FromInt32(5309), api.ProtocolTCP)), 7093 svctest.SetNodePorts(30076, 0), // set [0] to [1]'s value, omit [1] 7094 svctest.SetHealthCheckNodePort(30118)), 7095 expectClusterIPs: true, 7096 expectNodePorts: true, 7097 expectHealthCheckNodePort: true, 7098 prove: prove( 7099 proveNodePort(0, 30076), 7100 proveNodePort(1, -30076), 7101 proveHCNP(30118)), 7102 }, 7103 }, { 7104 name: "swap-port-with-hcnp", 7105 create: svcTestCase{ 7106 svc: svctest.MakeService("foo", 7107 svctest.SetTypeLoadBalancer, 7108 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal), 7109 svctest.SetPorts( 7110 svctest.MakeServicePort("p", 867, intstr.FromInt32(867), api.ProtocolTCP), 7111 svctest.MakeServicePort("q", 5309, intstr.FromInt32(5309), api.ProtocolTCP)), 7112 svctest.SetNodePorts(30093, 30076), 7113 svctest.SetHealthCheckNodePort(30118)), 7114 expectClusterIPs: true, 7115 expectNodePorts: true, 7116 expectHealthCheckNodePort: true, 7117 }, 7118 update: svcTestCase{ 7119 svc: svctest.MakeService("foo", 7120 svctest.SetTypeLoadBalancer, 7121 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal), 7122 svctest.SetPorts( 7123 svctest.MakeServicePort("p", 867, intstr.FromInt32(867), api.ProtocolTCP), 7124 svctest.MakeServicePort("q", 5309, intstr.FromInt32(5309), api.ProtocolTCP)), 7125 svctest.SetNodePorts(30076, 30118)), // set [0] to HCNP's value 7126 expectError: true, 7127 }, 7128 }, { 7129 name: "partial-swap-port-with-hcnp", 7130 create: svcTestCase{ 7131 svc: svctest.MakeService("foo", 7132 svctest.SetTypeLoadBalancer, 7133 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal), 7134 svctest.SetPorts( 7135 svctest.MakeServicePort("p", 867, intstr.FromInt32(867), api.ProtocolTCP), 7136 svctest.MakeServicePort("q", 5309, intstr.FromInt32(5309), api.ProtocolTCP)), 7137 svctest.SetNodePorts(30093, 30076), 7138 svctest.SetHealthCheckNodePort(30118)), 7139 expectClusterIPs: true, 7140 expectNodePorts: true, 7141 expectHealthCheckNodePort: true, 7142 }, 7143 update: svcTestCase{ 7144 svc: svctest.MakeService("foo", 7145 svctest.SetTypeLoadBalancer, 7146 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal), 7147 svctest.SetPorts( 7148 svctest.MakeServicePort("p", 867, intstr.FromInt32(867), api.ProtocolTCP), 7149 svctest.MakeServicePort("q", 5309, intstr.FromInt32(5309), api.ProtocolTCP)), 7150 svctest.SetNodePorts(30118, 0)), // set [0] to HCNP's value, omit [1] 7151 expectError: true, 7152 }, 7153 }, { 7154 name: "update-hcnp", 7155 create: svcTestCase{ 7156 svc: svctest.MakeService("foo", 7157 svctest.SetTypeLoadBalancer, 7158 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal), 7159 svctest.SetPorts( 7160 svctest.MakeServicePort("p", 867, intstr.FromInt32(867), api.ProtocolTCP), 7161 svctest.MakeServicePort("q", 5309, intstr.FromInt32(5309), api.ProtocolTCP)), 7162 svctest.SetNodePorts(30093, 30076), 7163 svctest.SetHealthCheckNodePort(30118)), 7164 expectClusterIPs: true, 7165 expectNodePorts: true, 7166 expectHealthCheckNodePort: true, 7167 }, 7168 update: svcTestCase{ 7169 svc: svctest.MakeService("foo", 7170 svctest.SetTypeLoadBalancer, 7171 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal), 7172 svctest.SetPorts( 7173 svctest.MakeServicePort("p", 867, intstr.FromInt32(867), api.ProtocolTCP), 7174 svctest.MakeServicePort("q", 5309, intstr.FromInt32(5309), api.ProtocolTCP)), 7175 svctest.SetNodePorts(30093, 30076), 7176 svctest.SetHealthCheckNodePort(30111)), 7177 expectError: true, 7178 }, 7179 }} 7180 7181 helpTestCreateUpdateDelete(t, testCases) 7182 } 7183 7184 // Proves that updates from single-stack work. 7185 func TestUpdateIPsFromSingleStack(t *testing.T) { 7186 prove := func(proofs ...svcTestProof) []svcTestProof { 7187 return proofs 7188 } 7189 proveNumFamilies := func(n int) svcTestProof { 7190 return func(t *testing.T, storage *wrapperRESTForTests, before, after *api.Service) { 7191 t.Helper() 7192 if got := len(after.Spec.IPFamilies); got != n { 7193 t.Errorf("wrong number of ipFamilies: expected %d, got %d", n, got) 7194 } 7195 } 7196 } 7197 7198 // Single-stack cases as control. 7199 testCasesV4 := []cudTestCase{{ 7200 name: "single-single", 7201 line: line(), 7202 create: svcTestCase{ 7203 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7204 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack)), 7205 expectClusterIPs: true, 7206 prove: prove(proveNumFamilies(1)), 7207 }, 7208 update: svcTestCase{ 7209 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7210 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7211 svctest.SetSelector(map[string]string{"k2": "v2"})), 7212 expectClusterIPs: true, 7213 prove: prove(proveNumFamilies(1)), 7214 }, 7215 }, { 7216 name: "single-dual", 7217 line: line(), 7218 create: svcTestCase{ 7219 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7220 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack)), 7221 expectClusterIPs: true, 7222 prove: prove(proveNumFamilies(1)), 7223 }, 7224 update: svcTestCase{ 7225 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7226 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 7227 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 7228 expectError: true, 7229 }, 7230 }, { 7231 name: "single-dual_policy", 7232 line: line(), 7233 create: svcTestCase{ 7234 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7235 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack)), 7236 expectClusterIPs: true, 7237 prove: prove(proveNumFamilies(1)), 7238 }, 7239 update: svcTestCase{ 7240 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7241 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack)), 7242 expectError: true, 7243 }, 7244 }, { 7245 name: "single-dual_families", 7246 line: line(), 7247 create: svcTestCase{ 7248 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7249 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack)), 7250 expectClusterIPs: true, 7251 prove: prove(proveNumFamilies(1)), 7252 }, 7253 update: svcTestCase{ 7254 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7255 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 7256 expectError: true, 7257 }, 7258 }} 7259 7260 t.Run("singlestack:v4", func(t *testing.T) { 7261 helpTestCreateUpdateDeleteWithFamilies(t, testCasesV4, []api.IPFamily{api.IPv4Protocol}) 7262 }) 7263 7264 // Dual-stack v4,v6 cases: Covers the full matrix of: 7265 // policy={nil, single, prefer, require} 7266 // families={nil, single, dual} 7267 // ips={nil, single, dual} 7268 testCasesV4V6 := []cudTestCase{{ 7269 name: "policy:nil_families:nil_ips:nil", 7270 line: line(), 7271 create: svcTestCase{ 7272 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7273 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7274 svctest.SetClusterIPs("10.0.0.1")), 7275 expectClusterIPs: true, 7276 prove: prove(proveNumFamilies(1)), 7277 }, 7278 update: svcTestCase{ 7279 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7280 svctest.SetSelector(map[string]string{"k2": "v2"})), 7281 expectClusterIPs: true, 7282 prove: prove(proveNumFamilies(1)), 7283 }, 7284 }, { 7285 name: "policy:nil_families:nil_ips:single", 7286 line: line(), 7287 create: svcTestCase{ 7288 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7289 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7290 svctest.SetClusterIPs("10.0.0.1")), 7291 expectClusterIPs: true, 7292 prove: prove(proveNumFamilies(1)), 7293 }, 7294 update: svcTestCase{ 7295 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7296 svctest.SetSelector(map[string]string{"k2": "v2"}), 7297 svctest.SetClusterIPs("10.0.0.1")), 7298 expectClusterIPs: true, 7299 prove: prove(proveNumFamilies(1)), 7300 }, 7301 }, { 7302 name: "policy:nil_families:nil_ips:dual", 7303 line: line(), 7304 create: svcTestCase{ 7305 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7306 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7307 svctest.SetClusterIPs("10.0.0.1")), 7308 expectClusterIPs: true, 7309 prove: prove(proveNumFamilies(1)), 7310 }, 7311 update: svcTestCase{ 7312 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7313 svctest.SetSelector(map[string]string{"k2": "v2"}), 7314 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 7315 expectError: true, 7316 }, 7317 }, { 7318 name: "policy:nil_families:single_ips:nil", 7319 line: line(), 7320 create: svcTestCase{ 7321 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7322 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7323 svctest.SetClusterIPs("10.0.0.1")), 7324 expectClusterIPs: true, 7325 prove: prove(proveNumFamilies(1)), 7326 }, 7327 update: svcTestCase{ 7328 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7329 svctest.SetSelector(map[string]string{"k2": "v2"}), 7330 svctest.SetIPFamilies(api.IPv4Protocol)), 7331 expectClusterIPs: true, 7332 prove: prove(proveNumFamilies(1)), 7333 }, 7334 }, { 7335 name: "policy:nil_families:single_ips:single", 7336 line: line(), 7337 create: svcTestCase{ 7338 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7339 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7340 svctest.SetClusterIPs("10.0.0.1")), 7341 expectClusterIPs: true, 7342 prove: prove(proveNumFamilies(1)), 7343 }, 7344 update: svcTestCase{ 7345 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7346 svctest.SetSelector(map[string]string{"k2": "v2"}), 7347 svctest.SetIPFamilies(api.IPv4Protocol), 7348 svctest.SetClusterIPs("10.0.0.1")), 7349 expectClusterIPs: true, 7350 prove: prove(proveNumFamilies(1)), 7351 }, 7352 }, { 7353 name: "policy:nil_families:single_ips:dual", 7354 line: line(), 7355 create: svcTestCase{ 7356 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7357 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7358 svctest.SetClusterIPs("10.0.0.1")), 7359 expectClusterIPs: true, 7360 prove: prove(proveNumFamilies(1)), 7361 }, 7362 update: svcTestCase{ 7363 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7364 svctest.SetSelector(map[string]string{"k2": "v2"}), 7365 svctest.SetIPFamilies(api.IPv4Protocol), 7366 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 7367 expectError: true, 7368 }, 7369 }, { 7370 name: "policy:nil_families:dual_ips:nil", 7371 line: line(), 7372 create: svcTestCase{ 7373 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7374 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7375 svctest.SetClusterIPs("10.0.0.1")), 7376 expectClusterIPs: true, 7377 prove: prove(proveNumFamilies(1)), 7378 }, 7379 update: svcTestCase{ 7380 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7381 svctest.SetSelector(map[string]string{"k2": "v2"}), 7382 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 7383 expectError: true, 7384 }, 7385 }, { 7386 name: "policy:nil_families:dual_ips:single", 7387 line: line(), 7388 create: svcTestCase{ 7389 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7390 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7391 svctest.SetClusterIPs("10.0.0.1")), 7392 expectClusterIPs: true, 7393 }, 7394 update: svcTestCase{ 7395 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7396 svctest.SetSelector(map[string]string{"k2": "v2"}), 7397 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol), 7398 svctest.SetClusterIPs("10.0.0.1")), 7399 expectError: true, 7400 }, 7401 }, { 7402 name: "policy:nil_families:dual_ips:dual", 7403 line: line(), 7404 create: svcTestCase{ 7405 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7406 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7407 svctest.SetClusterIPs("10.0.0.1")), 7408 expectClusterIPs: true, 7409 prove: prove(proveNumFamilies(1)), 7410 }, 7411 update: svcTestCase{ 7412 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7413 svctest.SetSelector(map[string]string{"k2": "v2"}), 7414 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol), 7415 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 7416 expectError: true, 7417 }, 7418 }, { 7419 name: "policy:single_families:nil_ips:nil", 7420 line: line(), 7421 create: svcTestCase{ 7422 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7423 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7424 svctest.SetClusterIPs("10.0.0.1")), 7425 expectClusterIPs: true, 7426 prove: prove(proveNumFamilies(1)), 7427 }, 7428 update: svcTestCase{ 7429 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7430 svctest.SetSelector(map[string]string{"k2": "v2"}), 7431 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack)), 7432 expectClusterIPs: true, 7433 prove: prove(proveNumFamilies(1)), 7434 }, 7435 }, { 7436 name: "policy:single_families:nil_ips:single", 7437 line: line(), 7438 create: svcTestCase{ 7439 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7440 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7441 svctest.SetClusterIPs("10.0.0.1")), 7442 expectClusterIPs: true, 7443 prove: prove(proveNumFamilies(1)), 7444 }, 7445 update: svcTestCase{ 7446 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7447 svctest.SetSelector(map[string]string{"k2": "v2"}), 7448 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7449 svctest.SetClusterIPs("10.0.0.1")), 7450 expectClusterIPs: true, 7451 prove: prove(proveNumFamilies(1)), 7452 }, 7453 }, { 7454 name: "policy:single_families:nil_ips:dual", 7455 line: line(), 7456 create: svcTestCase{ 7457 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7458 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7459 svctest.SetClusterIPs("10.0.0.1")), 7460 expectClusterIPs: true, 7461 prove: prove(proveNumFamilies(1)), 7462 }, 7463 update: svcTestCase{ 7464 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7465 svctest.SetSelector(map[string]string{"k2": "v2"}), 7466 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7467 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 7468 expectError: true, 7469 }, 7470 }, { 7471 name: "policy:single_families:single_ips:nil", 7472 line: line(), 7473 create: svcTestCase{ 7474 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7475 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7476 svctest.SetClusterIPs("10.0.0.1")), 7477 expectClusterIPs: true, 7478 prove: prove(proveNumFamilies(1)), 7479 }, 7480 update: svcTestCase{ 7481 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7482 svctest.SetSelector(map[string]string{"k2": "v2"}), 7483 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7484 svctest.SetIPFamilies(api.IPv4Protocol)), 7485 expectClusterIPs: true, 7486 prove: prove(proveNumFamilies(1)), 7487 }, 7488 }, { 7489 name: "policy:single_families:single_ips:single", 7490 line: line(), 7491 create: svcTestCase{ 7492 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7493 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7494 svctest.SetClusterIPs("10.0.0.1")), 7495 expectClusterIPs: true, 7496 prove: prove(proveNumFamilies(1)), 7497 }, 7498 update: svcTestCase{ 7499 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7500 svctest.SetSelector(map[string]string{"k2": "v2"}), 7501 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7502 svctest.SetIPFamilies(api.IPv4Protocol), 7503 svctest.SetClusterIPs("10.0.0.1")), 7504 expectClusterIPs: true, 7505 prove: prove(proveNumFamilies(1)), 7506 }, 7507 }, { 7508 name: "policy:single_families:single_ips:dual", 7509 line: line(), 7510 create: svcTestCase{ 7511 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7512 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7513 svctest.SetClusterIPs("10.0.0.1")), 7514 expectClusterIPs: true, 7515 prove: prove(proveNumFamilies(1)), 7516 }, 7517 update: svcTestCase{ 7518 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7519 svctest.SetSelector(map[string]string{"k2": "v2"}), 7520 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7521 svctest.SetIPFamilies(api.IPv4Protocol), 7522 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 7523 expectError: true, 7524 }, 7525 }, { 7526 name: "policy:single_families:dual_ips:nil", 7527 line: line(), 7528 create: svcTestCase{ 7529 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7530 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7531 svctest.SetClusterIPs("10.0.0.1")), 7532 expectClusterIPs: true, 7533 prove: prove(proveNumFamilies(1)), 7534 }, 7535 update: svcTestCase{ 7536 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7537 svctest.SetSelector(map[string]string{"k2": "v2"}), 7538 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7539 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 7540 expectError: true, 7541 }, 7542 }, { 7543 name: "policy:single_families:dual_ips:single", 7544 line: line(), 7545 create: svcTestCase{ 7546 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7547 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7548 svctest.SetClusterIPs("10.0.0.1")), 7549 expectClusterIPs: true, 7550 prove: prove(proveNumFamilies(1)), 7551 }, 7552 update: svcTestCase{ 7553 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7554 svctest.SetSelector(map[string]string{"k2": "v2"}), 7555 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7556 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol), 7557 svctest.SetClusterIPs("10.0.0.1")), 7558 expectError: true, 7559 }, 7560 }, { 7561 name: "policy:single_families:dual_ips:dual", 7562 line: line(), 7563 create: svcTestCase{ 7564 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7565 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7566 svctest.SetClusterIPs("10.0.0.1")), 7567 expectClusterIPs: true, 7568 prove: prove(proveNumFamilies(1)), 7569 }, 7570 update: svcTestCase{ 7571 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7572 svctest.SetSelector(map[string]string{"k2": "v2"}), 7573 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7574 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol), 7575 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 7576 expectError: true, 7577 }, 7578 }, { 7579 name: "policy:prefer_families:nil_ips:nil", 7580 line: line(), 7581 create: svcTestCase{ 7582 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7583 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7584 svctest.SetClusterIPs("10.0.0.1")), 7585 expectClusterIPs: true, 7586 prove: prove(proveNumFamilies(1)), 7587 }, 7588 update: svcTestCase{ 7589 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7590 svctest.SetSelector(map[string]string{"k2": "v2"}), 7591 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack)), 7592 expectClusterIPs: true, 7593 prove: prove(proveNumFamilies(2)), 7594 }, 7595 }, { 7596 name: "policy:prefer_families:nil_ips:single", 7597 line: line(), 7598 create: svcTestCase{ 7599 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7600 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7601 svctest.SetClusterIPs("10.0.0.1")), 7602 expectClusterIPs: true, 7603 prove: prove(proveNumFamilies(1)), 7604 }, 7605 update: svcTestCase{ 7606 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7607 svctest.SetSelector(map[string]string{"k2": "v2"}), 7608 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 7609 svctest.SetClusterIPs("10.0.0.1")), 7610 expectClusterIPs: true, 7611 prove: prove(proveNumFamilies(2)), 7612 }, 7613 }, { 7614 name: "policy:prefer_families:nil_ips:dual", 7615 line: line(), 7616 create: svcTestCase{ 7617 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7618 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7619 svctest.SetClusterIPs("10.0.0.1")), 7620 expectClusterIPs: true, 7621 prove: prove(proveNumFamilies(1)), 7622 }, 7623 update: svcTestCase{ 7624 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7625 svctest.SetSelector(map[string]string{"k2": "v2"}), 7626 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 7627 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 7628 expectClusterIPs: true, 7629 prove: prove(proveNumFamilies(2)), 7630 }, 7631 }, { 7632 name: "policy:prefer_families:single_ips:nil", 7633 line: line(), 7634 create: svcTestCase{ 7635 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7636 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7637 svctest.SetClusterIPs("10.0.0.1")), 7638 expectClusterIPs: true, 7639 prove: prove(proveNumFamilies(1)), 7640 }, 7641 update: svcTestCase{ 7642 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7643 svctest.SetSelector(map[string]string{"k2": "v2"}), 7644 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 7645 svctest.SetIPFamilies(api.IPv4Protocol)), 7646 expectClusterIPs: true, 7647 prove: prove(proveNumFamilies(2)), 7648 }, 7649 }, { 7650 name: "policy:prefer_families:single_ips:single", 7651 line: line(), 7652 create: svcTestCase{ 7653 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7654 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7655 svctest.SetClusterIPs("10.0.0.1")), 7656 expectClusterIPs: true, 7657 prove: prove(proveNumFamilies(1)), 7658 }, 7659 update: svcTestCase{ 7660 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7661 svctest.SetSelector(map[string]string{"k2": "v2"}), 7662 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 7663 svctest.SetIPFamilies(api.IPv4Protocol), 7664 svctest.SetClusterIPs("10.0.0.1")), 7665 expectClusterIPs: true, 7666 prove: prove(proveNumFamilies(2)), 7667 }, 7668 }, { 7669 name: "policy:prefer_families:single_ips:dual", 7670 line: line(), 7671 create: svcTestCase{ 7672 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7673 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7674 svctest.SetClusterIPs("10.0.0.1")), 7675 expectClusterIPs: true, 7676 prove: prove(proveNumFamilies(1)), 7677 }, 7678 update: svcTestCase{ 7679 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7680 svctest.SetSelector(map[string]string{"k2": "v2"}), 7681 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 7682 svctest.SetIPFamilies(api.IPv4Protocol), 7683 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 7684 expectClusterIPs: true, 7685 prove: prove(proveNumFamilies(2)), 7686 }, 7687 }, { 7688 name: "policy:prefer_families:dual_ips:nil", 7689 line: line(), 7690 create: svcTestCase{ 7691 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7692 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7693 svctest.SetClusterIPs("10.0.0.1")), 7694 expectClusterIPs: true, 7695 prove: prove(proveNumFamilies(1)), 7696 }, 7697 update: svcTestCase{ 7698 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7699 svctest.SetSelector(map[string]string{"k2": "v2"}), 7700 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 7701 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 7702 expectClusterIPs: true, 7703 prove: prove(proveNumFamilies(2)), 7704 }, 7705 }, { 7706 name: "policy:prefer_families:dual_ips:single", 7707 line: line(), 7708 create: svcTestCase{ 7709 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7710 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7711 svctest.SetClusterIPs("10.0.0.1")), 7712 expectClusterIPs: true, 7713 prove: prove(proveNumFamilies(1)), 7714 }, 7715 update: svcTestCase{ 7716 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7717 svctest.SetSelector(map[string]string{"k2": "v2"}), 7718 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 7719 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol), 7720 svctest.SetClusterIPs("10.0.0.1")), 7721 expectClusterIPs: true, 7722 prove: prove(proveNumFamilies(2)), 7723 }, 7724 }, { 7725 name: "policy:prefer_families:dual_ips:dual", 7726 line: line(), 7727 create: svcTestCase{ 7728 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7729 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7730 svctest.SetClusterIPs("10.0.0.1")), 7731 expectClusterIPs: true, 7732 prove: prove(proveNumFamilies(1)), 7733 }, 7734 update: svcTestCase{ 7735 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7736 svctest.SetSelector(map[string]string{"k2": "v2"}), 7737 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 7738 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol), 7739 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 7740 expectClusterIPs: true, 7741 prove: prove(proveNumFamilies(2)), 7742 }, 7743 }, { 7744 name: "policy:require_families:nil_ips:nil", 7745 line: line(), 7746 create: svcTestCase{ 7747 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7748 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7749 svctest.SetClusterIPs("10.0.0.1")), 7750 expectClusterIPs: true, 7751 prove: prove(proveNumFamilies(1)), 7752 }, 7753 update: svcTestCase{ 7754 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7755 svctest.SetSelector(map[string]string{"k2": "v2"}), 7756 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack)), 7757 expectClusterIPs: true, 7758 prove: prove(proveNumFamilies(2)), 7759 }, 7760 }, { 7761 name: "policy:require_families:nil_ips:single", 7762 line: line(), 7763 create: svcTestCase{ 7764 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7765 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7766 svctest.SetClusterIPs("10.0.0.1")), 7767 expectClusterIPs: true, 7768 prove: prove(proveNumFamilies(1)), 7769 }, 7770 update: svcTestCase{ 7771 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7772 svctest.SetSelector(map[string]string{"k2": "v2"}), 7773 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 7774 svctest.SetClusterIPs("10.0.0.1")), 7775 expectClusterIPs: true, 7776 prove: prove(proveNumFamilies(2)), 7777 }, 7778 }, { 7779 name: "policy:require_families:nil_ips:dual", 7780 line: line(), 7781 create: svcTestCase{ 7782 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7783 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7784 svctest.SetClusterIPs("10.0.0.1")), 7785 expectClusterIPs: true, 7786 prove: prove(proveNumFamilies(1)), 7787 }, 7788 update: svcTestCase{ 7789 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7790 svctest.SetSelector(map[string]string{"k2": "v2"}), 7791 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 7792 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 7793 expectClusterIPs: true, 7794 prove: prove(proveNumFamilies(2)), 7795 }, 7796 }, { 7797 name: "policy:require_families:single_ips:nil", 7798 line: line(), 7799 create: svcTestCase{ 7800 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7801 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7802 svctest.SetClusterIPs("10.0.0.1")), 7803 expectClusterIPs: true, 7804 prove: prove(proveNumFamilies(1)), 7805 }, 7806 update: svcTestCase{ 7807 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7808 svctest.SetSelector(map[string]string{"k2": "v2"}), 7809 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 7810 svctest.SetIPFamilies(api.IPv4Protocol)), 7811 expectClusterIPs: true, 7812 prove: prove(proveNumFamilies(2)), 7813 }, 7814 }, { 7815 name: "policy:require_families:single_ips:single", 7816 line: line(), 7817 create: svcTestCase{ 7818 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7819 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7820 svctest.SetClusterIPs("10.0.0.1")), 7821 expectClusterIPs: true, 7822 prove: prove(proveNumFamilies(1)), 7823 }, 7824 update: svcTestCase{ 7825 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7826 svctest.SetSelector(map[string]string{"k2": "v2"}), 7827 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 7828 svctest.SetIPFamilies(api.IPv4Protocol), 7829 svctest.SetClusterIPs("10.0.0.1")), 7830 expectClusterIPs: true, 7831 prove: prove(proveNumFamilies(2)), 7832 }, 7833 }, { 7834 name: "policy:require_families:single_ips:dual", 7835 line: line(), 7836 create: svcTestCase{ 7837 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7838 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7839 svctest.SetClusterIPs("10.0.0.1")), 7840 expectClusterIPs: true, 7841 prove: prove(proveNumFamilies(1)), 7842 }, 7843 update: svcTestCase{ 7844 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7845 svctest.SetSelector(map[string]string{"k2": "v2"}), 7846 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 7847 svctest.SetIPFamilies(api.IPv4Protocol), 7848 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 7849 expectClusterIPs: true, 7850 prove: prove(proveNumFamilies(2)), 7851 }, 7852 }, { 7853 name: "policy:require_families:dual_ips:nil", 7854 line: line(), 7855 create: svcTestCase{ 7856 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7857 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7858 svctest.SetClusterIPs("10.0.0.1")), 7859 expectClusterIPs: true, 7860 prove: prove(proveNumFamilies(1)), 7861 }, 7862 update: svcTestCase{ 7863 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7864 svctest.SetSelector(map[string]string{"k2": "v2"}), 7865 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 7866 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 7867 expectClusterIPs: true, 7868 prove: prove(proveNumFamilies(2)), 7869 }, 7870 }, { 7871 name: "policy:require_families:dual_ips:single", 7872 line: line(), 7873 create: svcTestCase{ 7874 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7875 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7876 svctest.SetClusterIPs("10.0.0.1")), 7877 expectClusterIPs: true, 7878 prove: prove(proveNumFamilies(1)), 7879 }, 7880 update: svcTestCase{ 7881 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7882 svctest.SetSelector(map[string]string{"k2": "v2"}), 7883 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 7884 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol), 7885 svctest.SetClusterIPs("10.0.0.1")), 7886 expectClusterIPs: true, 7887 prove: prove(proveNumFamilies(2)), 7888 }, 7889 }, { 7890 name: "policy:require_families:dual_ips:dual", 7891 line: line(), 7892 create: svcTestCase{ 7893 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7894 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7895 svctest.SetClusterIPs("10.0.0.1")), 7896 expectClusterIPs: true, 7897 prove: prove(proveNumFamilies(1)), 7898 }, 7899 update: svcTestCase{ 7900 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7901 svctest.SetSelector(map[string]string{"k2": "v2"}), 7902 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 7903 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol), 7904 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 7905 expectClusterIPs: true, 7906 prove: prove(proveNumFamilies(2)), 7907 }, 7908 }, { 7909 name: "single-dual_wrong_order_families", 7910 line: line(), 7911 create: svcTestCase{ 7912 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7913 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7914 svctest.SetClusterIPs("10.0.0.1")), 7915 expectClusterIPs: true, 7916 prove: prove(proveNumFamilies(1)), 7917 }, 7918 update: svcTestCase{ 7919 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7920 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 7921 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 7922 expectError: true, 7923 }, 7924 }, { 7925 name: "single-dual_wrong_order_ips", 7926 line: line(), 7927 create: svcTestCase{ 7928 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7929 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7930 svctest.SetClusterIPs("10.0.0.1")), 7931 expectClusterIPs: true, 7932 prove: prove(proveNumFamilies(1)), 7933 }, 7934 update: svcTestCase{ 7935 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7936 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 7937 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 7938 expectError: true, 7939 }, 7940 }, { 7941 name: "single-dual_ip_in_use", 7942 line: line(), 7943 create: svcTestCase{ 7944 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7945 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7946 svctest.SetClusterIPs("10.0.0.1")), 7947 expectClusterIPs: true, 7948 prove: prove(proveNumFamilies(1)), 7949 }, 7950 beforeUpdate: func(t *testing.T, storage *wrapperRESTForTests) { 7951 alloc := storage.alloc.serviceIPAllocatorsByFamily[api.IPv6Protocol] 7952 ip := "2000::1" 7953 if err := alloc.Allocate(netutils.ParseIPSloppy(ip)); err != nil { 7954 t.Fatalf("test is incorrect, unable to preallocate IP %q: %v", ip, err) 7955 } 7956 }, 7957 update: svcTestCase{ 7958 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7959 svctest.SetSelector(map[string]string{"k2": "v2"}), 7960 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 7961 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol), 7962 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 7963 expectError: true, 7964 }, 7965 }} 7966 7967 t.Run("dualstack:v4v6", func(t *testing.T) { 7968 helpTestCreateUpdateDeleteWithFamilies(t, testCasesV4V6, []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}) 7969 }) 7970 7971 // Dual-stack v6,v4 cases: Covers the full matrix of: 7972 // policy={nil, single, prefer, require} 7973 // families={nil, single, dual} 7974 // ips={nil, single, dual} 7975 testCasesV6V4 := []cudTestCase{{ 7976 name: "policy:nil_families:nil_ips:nil", 7977 line: line(), 7978 create: svcTestCase{ 7979 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7980 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7981 svctest.SetClusterIPs("2000::1")), 7982 expectClusterIPs: true, 7983 prove: prove(proveNumFamilies(1)), 7984 }, 7985 update: svcTestCase{ 7986 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7987 svctest.SetSelector(map[string]string{"k2": "v2"})), 7988 expectClusterIPs: true, 7989 prove: prove(proveNumFamilies(1)), 7990 }, 7991 }, { 7992 name: "policy:nil_families:nil_ips:single", 7993 line: line(), 7994 create: svcTestCase{ 7995 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 7996 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 7997 svctest.SetClusterIPs("2000::1")), 7998 expectClusterIPs: true, 7999 prove: prove(proveNumFamilies(1)), 8000 }, 8001 update: svcTestCase{ 8002 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8003 svctest.SetSelector(map[string]string{"k2": "v2"}), 8004 svctest.SetClusterIPs("2000::1")), 8005 expectClusterIPs: true, 8006 prove: prove(proveNumFamilies(1)), 8007 }, 8008 }, { 8009 name: "policy:nil_families:nil_ips:dual", 8010 line: line(), 8011 create: svcTestCase{ 8012 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8013 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8014 svctest.SetClusterIPs("2000::1")), 8015 expectClusterIPs: true, 8016 prove: prove(proveNumFamilies(1)), 8017 }, 8018 update: svcTestCase{ 8019 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8020 svctest.SetSelector(map[string]string{"k2": "v2"}), 8021 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 8022 expectError: true, 8023 }, 8024 }, { 8025 name: "policy:nil_families:single_ips:nil", 8026 line: line(), 8027 create: svcTestCase{ 8028 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8029 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8030 svctest.SetClusterIPs("2000::1")), 8031 expectClusterIPs: true, 8032 prove: prove(proveNumFamilies(1)), 8033 }, 8034 update: svcTestCase{ 8035 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8036 svctest.SetSelector(map[string]string{"k2": "v2"}), 8037 svctest.SetIPFamilies(api.IPv6Protocol)), 8038 expectClusterIPs: true, 8039 prove: prove(proveNumFamilies(1)), 8040 }, 8041 }, { 8042 name: "policy:nil_families:single_ips:single", 8043 line: line(), 8044 create: svcTestCase{ 8045 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8046 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8047 svctest.SetClusterIPs("2000::1")), 8048 expectClusterIPs: true, 8049 prove: prove(proveNumFamilies(1)), 8050 }, 8051 update: svcTestCase{ 8052 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8053 svctest.SetSelector(map[string]string{"k2": "v2"}), 8054 svctest.SetIPFamilies(api.IPv6Protocol), 8055 svctest.SetClusterIPs("2000::1")), 8056 expectClusterIPs: true, 8057 prove: prove(proveNumFamilies(1)), 8058 }, 8059 }, { 8060 name: "policy:nil_families:single_ips:dual", 8061 line: line(), 8062 create: svcTestCase{ 8063 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8064 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8065 svctest.SetClusterIPs("2000::1")), 8066 expectClusterIPs: true, 8067 prove: prove(proveNumFamilies(1)), 8068 }, 8069 update: svcTestCase{ 8070 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8071 svctest.SetSelector(map[string]string{"k2": "v2"}), 8072 svctest.SetIPFamilies(api.IPv6Protocol), 8073 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 8074 expectError: true, 8075 }, 8076 }, { 8077 name: "policy:nil_families:dual_ips:nil", 8078 line: line(), 8079 create: svcTestCase{ 8080 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8081 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8082 svctest.SetClusterIPs("2000::1")), 8083 expectClusterIPs: true, 8084 prove: prove(proveNumFamilies(1)), 8085 }, 8086 update: svcTestCase{ 8087 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8088 svctest.SetSelector(map[string]string{"k2": "v2"}), 8089 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 8090 expectError: true, 8091 }, 8092 }, { 8093 name: "policy:nil_families:dual_ips:single", 8094 line: line(), 8095 create: svcTestCase{ 8096 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8097 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8098 svctest.SetClusterIPs("2000::1")), 8099 expectClusterIPs: true, 8100 prove: prove(proveNumFamilies(1)), 8101 }, 8102 update: svcTestCase{ 8103 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8104 svctest.SetSelector(map[string]string{"k2": "v2"}), 8105 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol), 8106 svctest.SetClusterIPs("2000::1")), 8107 expectError: true, 8108 }, 8109 }, { 8110 name: "policy:nil_families:dual_ips:dual", 8111 line: line(), 8112 create: svcTestCase{ 8113 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8114 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8115 svctest.SetClusterIPs("2000::1")), 8116 expectClusterIPs: true, 8117 prove: prove(proveNumFamilies(1)), 8118 }, 8119 update: svcTestCase{ 8120 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8121 svctest.SetSelector(map[string]string{"k2": "v2"}), 8122 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol), 8123 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 8124 expectError: true, 8125 }, 8126 }, { 8127 name: "policy:single_families:nil_ips:nil", 8128 line: line(), 8129 create: svcTestCase{ 8130 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8131 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8132 svctest.SetClusterIPs("2000::1")), 8133 expectClusterIPs: true, 8134 prove: prove(proveNumFamilies(1)), 8135 }, 8136 update: svcTestCase{ 8137 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8138 svctest.SetSelector(map[string]string{"k2": "v2"}), 8139 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack)), 8140 expectClusterIPs: true, 8141 prove: prove(proveNumFamilies(1)), 8142 }, 8143 }, { 8144 name: "policy:single_families:nil_ips:single", 8145 line: line(), 8146 create: svcTestCase{ 8147 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8148 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8149 svctest.SetClusterIPs("2000::1")), 8150 expectClusterIPs: true, 8151 prove: prove(proveNumFamilies(1)), 8152 }, 8153 update: svcTestCase{ 8154 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8155 svctest.SetSelector(map[string]string{"k2": "v2"}), 8156 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8157 svctest.SetClusterIPs("2000::1")), 8158 expectClusterIPs: true, 8159 prove: prove(proveNumFamilies(1)), 8160 }, 8161 }, { 8162 name: "policy:single_families:nil_ips:dual", 8163 line: line(), 8164 create: svcTestCase{ 8165 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8166 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8167 svctest.SetClusterIPs("2000::1")), 8168 expectClusterIPs: true, 8169 prove: prove(proveNumFamilies(1)), 8170 }, 8171 update: svcTestCase{ 8172 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8173 svctest.SetSelector(map[string]string{"k2": "v2"}), 8174 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8175 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 8176 expectError: true, 8177 }, 8178 }, { 8179 name: "policy:single_families:single_ips:nil", 8180 line: line(), 8181 create: svcTestCase{ 8182 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8183 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8184 svctest.SetClusterIPs("2000::1")), 8185 expectClusterIPs: true, 8186 prove: prove(proveNumFamilies(1)), 8187 }, 8188 update: svcTestCase{ 8189 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8190 svctest.SetSelector(map[string]string{"k2": "v2"}), 8191 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8192 svctest.SetIPFamilies(api.IPv6Protocol)), 8193 expectClusterIPs: true, 8194 prove: prove(proveNumFamilies(1)), 8195 }, 8196 }, { 8197 name: "policy:single_families:single_ips:single", 8198 line: line(), 8199 create: svcTestCase{ 8200 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8201 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8202 svctest.SetClusterIPs("2000::1")), 8203 expectClusterIPs: true, 8204 prove: prove(proveNumFamilies(1)), 8205 }, 8206 update: svcTestCase{ 8207 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8208 svctest.SetSelector(map[string]string{"k2": "v2"}), 8209 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8210 svctest.SetIPFamilies(api.IPv6Protocol), 8211 svctest.SetClusterIPs("2000::1")), 8212 expectClusterIPs: true, 8213 prove: prove(proveNumFamilies(1)), 8214 }, 8215 }, { 8216 name: "policy:single_families:single_ips:dual", 8217 line: line(), 8218 create: svcTestCase{ 8219 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8220 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8221 svctest.SetClusterIPs("2000::1")), 8222 expectClusterIPs: true, 8223 prove: prove(proveNumFamilies(1)), 8224 }, 8225 update: svcTestCase{ 8226 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8227 svctest.SetSelector(map[string]string{"k2": "v2"}), 8228 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8229 svctest.SetIPFamilies(api.IPv6Protocol), 8230 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 8231 expectError: true, 8232 }, 8233 }, { 8234 name: "policy:single_families:dual_ips:nil", 8235 line: line(), 8236 create: svcTestCase{ 8237 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8238 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8239 svctest.SetClusterIPs("2000::1")), 8240 expectClusterIPs: true, 8241 prove: prove(proveNumFamilies(1)), 8242 }, 8243 update: svcTestCase{ 8244 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8245 svctest.SetSelector(map[string]string{"k2": "v2"}), 8246 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8247 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 8248 expectError: true, 8249 }, 8250 }, { 8251 name: "policy:single_families:dual_ips:single", 8252 line: line(), 8253 create: svcTestCase{ 8254 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8255 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8256 svctest.SetClusterIPs("2000::1")), 8257 expectClusterIPs: true, 8258 prove: prove(proveNumFamilies(1)), 8259 }, 8260 update: svcTestCase{ 8261 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8262 svctest.SetSelector(map[string]string{"k2": "v2"}), 8263 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8264 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol), 8265 svctest.SetClusterIPs("2000::1")), 8266 expectError: true, 8267 }, 8268 }, { 8269 name: "policy:single_families:dual_ips:dual", 8270 line: line(), 8271 create: svcTestCase{ 8272 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8273 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8274 svctest.SetClusterIPs("2000::1")), 8275 expectClusterIPs: true, 8276 prove: prove(proveNumFamilies(1)), 8277 }, 8278 update: svcTestCase{ 8279 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8280 svctest.SetSelector(map[string]string{"k2": "v2"}), 8281 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8282 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol), 8283 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 8284 expectError: true, 8285 }, 8286 }, { 8287 name: "policy:prefer_families:nil_ips:nil", 8288 line: line(), 8289 create: svcTestCase{ 8290 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8291 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8292 svctest.SetClusterIPs("2000::1")), 8293 expectClusterIPs: true, 8294 prove: prove(proveNumFamilies(1)), 8295 }, 8296 update: svcTestCase{ 8297 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8298 svctest.SetSelector(map[string]string{"k2": "v2"}), 8299 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack)), 8300 expectClusterIPs: true, 8301 prove: prove(proveNumFamilies(2)), 8302 }, 8303 }, { 8304 name: "policy:prefer_families:nil_ips:single", 8305 line: line(), 8306 create: svcTestCase{ 8307 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8308 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8309 svctest.SetClusterIPs("2000::1")), 8310 expectClusterIPs: true, 8311 prove: prove(proveNumFamilies(1)), 8312 }, 8313 update: svcTestCase{ 8314 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8315 svctest.SetSelector(map[string]string{"k2": "v2"}), 8316 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 8317 svctest.SetClusterIPs("2000::1")), 8318 expectClusterIPs: true, 8319 prove: prove(proveNumFamilies(2)), 8320 }, 8321 }, { 8322 name: "policy:prefer_families:nil_ips:dual", 8323 line: line(), 8324 create: svcTestCase{ 8325 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8326 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8327 svctest.SetClusterIPs("2000::1")), 8328 expectClusterIPs: true, 8329 prove: prove(proveNumFamilies(1)), 8330 }, 8331 update: svcTestCase{ 8332 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8333 svctest.SetSelector(map[string]string{"k2": "v2"}), 8334 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 8335 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 8336 expectClusterIPs: true, 8337 prove: prove(proveNumFamilies(2)), 8338 }, 8339 }, { 8340 name: "policy:prefer_families:single_ips:nil", 8341 line: line(), 8342 create: svcTestCase{ 8343 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8344 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8345 svctest.SetClusterIPs("2000::1")), 8346 expectClusterIPs: true, 8347 prove: prove(proveNumFamilies(1)), 8348 }, 8349 update: svcTestCase{ 8350 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8351 svctest.SetSelector(map[string]string{"k2": "v2"}), 8352 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 8353 svctest.SetIPFamilies(api.IPv6Protocol)), 8354 expectClusterIPs: true, 8355 prove: prove(proveNumFamilies(2)), 8356 }, 8357 }, { 8358 name: "policy:prefer_families:single_ips:single", 8359 line: line(), 8360 create: svcTestCase{ 8361 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8362 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8363 svctest.SetClusterIPs("2000::1")), 8364 expectClusterIPs: true, 8365 prove: prove(proveNumFamilies(1)), 8366 }, 8367 update: svcTestCase{ 8368 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8369 svctest.SetSelector(map[string]string{"k2": "v2"}), 8370 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 8371 svctest.SetIPFamilies(api.IPv6Protocol), 8372 svctest.SetClusterIPs("2000::1")), 8373 expectClusterIPs: true, 8374 prove: prove(proveNumFamilies(2)), 8375 }, 8376 }, { 8377 name: "policy:prefer_families:single_ips:dual", 8378 line: line(), 8379 create: svcTestCase{ 8380 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8381 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8382 svctest.SetClusterIPs("2000::1")), 8383 expectClusterIPs: true, 8384 prove: prove(proveNumFamilies(1)), 8385 }, 8386 update: svcTestCase{ 8387 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8388 svctest.SetSelector(map[string]string{"k2": "v2"}), 8389 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 8390 svctest.SetIPFamilies(api.IPv6Protocol), 8391 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 8392 expectClusterIPs: true, 8393 prove: prove(proveNumFamilies(2)), 8394 }, 8395 }, { 8396 name: "policy:prefer_families:dual_ips:nil", 8397 line: line(), 8398 create: svcTestCase{ 8399 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8400 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8401 svctest.SetClusterIPs("2000::1")), 8402 expectClusterIPs: true, 8403 prove: prove(proveNumFamilies(1)), 8404 }, 8405 update: svcTestCase{ 8406 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8407 svctest.SetSelector(map[string]string{"k2": "v2"}), 8408 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 8409 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 8410 expectClusterIPs: true, 8411 prove: prove(proveNumFamilies(2)), 8412 }, 8413 }, { 8414 name: "policy:prefer_families:dual_ips:single", 8415 line: line(), 8416 create: svcTestCase{ 8417 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8418 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8419 svctest.SetClusterIPs("2000::1")), 8420 expectClusterIPs: true, 8421 prove: prove(proveNumFamilies(1)), 8422 }, 8423 update: svcTestCase{ 8424 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8425 svctest.SetSelector(map[string]string{"k2": "v2"}), 8426 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 8427 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol), 8428 svctest.SetClusterIPs("2000::1")), 8429 expectClusterIPs: true, 8430 prove: prove(proveNumFamilies(2)), 8431 }, 8432 }, { 8433 name: "policy:prefer_families:dual_ips:dual", 8434 line: line(), 8435 create: svcTestCase{ 8436 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8437 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8438 svctest.SetClusterIPs("2000::1")), 8439 expectClusterIPs: true, 8440 prove: prove(proveNumFamilies(1)), 8441 }, 8442 update: svcTestCase{ 8443 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8444 svctest.SetSelector(map[string]string{"k2": "v2"}), 8445 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 8446 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol), 8447 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 8448 expectClusterIPs: true, 8449 prove: prove(proveNumFamilies(2)), 8450 }, 8451 }, { 8452 name: "policy:require_families:nil_ips:nil", 8453 line: line(), 8454 create: svcTestCase{ 8455 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8456 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8457 svctest.SetClusterIPs("2000::1")), 8458 expectClusterIPs: true, 8459 prove: prove(proveNumFamilies(1)), 8460 }, 8461 update: svcTestCase{ 8462 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8463 svctest.SetSelector(map[string]string{"k2": "v2"}), 8464 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack)), 8465 expectClusterIPs: true, 8466 prove: prove(proveNumFamilies(2)), 8467 }, 8468 }, { 8469 name: "policy:require_families:nil_ips:single", 8470 line: line(), 8471 create: svcTestCase{ 8472 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8473 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8474 svctest.SetClusterIPs("2000::1")), 8475 expectClusterIPs: true, 8476 prove: prove(proveNumFamilies(1)), 8477 }, 8478 update: svcTestCase{ 8479 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8480 svctest.SetSelector(map[string]string{"k2": "v2"}), 8481 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 8482 svctest.SetClusterIPs("2000::1")), 8483 expectClusterIPs: true, 8484 prove: prove(proveNumFamilies(2)), 8485 }, 8486 }, { 8487 name: "policy:require_families:nil_ips:dual", 8488 line: line(), 8489 create: svcTestCase{ 8490 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8491 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8492 svctest.SetClusterIPs("2000::1")), 8493 expectClusterIPs: true, 8494 prove: prove(proveNumFamilies(1)), 8495 }, 8496 update: svcTestCase{ 8497 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8498 svctest.SetSelector(map[string]string{"k2": "v2"}), 8499 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 8500 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 8501 expectClusterIPs: true, 8502 prove: prove(proveNumFamilies(2)), 8503 }, 8504 }, { 8505 name: "policy:require_families:single_ips:nil", 8506 line: line(), 8507 create: svcTestCase{ 8508 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8509 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8510 svctest.SetClusterIPs("2000::1")), 8511 expectClusterIPs: true, 8512 prove: prove(proveNumFamilies(1)), 8513 }, 8514 update: svcTestCase{ 8515 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8516 svctest.SetSelector(map[string]string{"k2": "v2"}), 8517 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 8518 svctest.SetIPFamilies(api.IPv6Protocol)), 8519 expectClusterIPs: true, 8520 prove: prove(proveNumFamilies(2)), 8521 }, 8522 }, { 8523 name: "policy:require_families:single_ips:single", 8524 line: line(), 8525 create: svcTestCase{ 8526 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8527 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8528 svctest.SetClusterIPs("2000::1")), 8529 expectClusterIPs: true, 8530 prove: prove(proveNumFamilies(1)), 8531 }, 8532 update: svcTestCase{ 8533 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8534 svctest.SetSelector(map[string]string{"k2": "v2"}), 8535 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 8536 svctest.SetIPFamilies(api.IPv6Protocol), 8537 svctest.SetClusterIPs("2000::1")), 8538 expectClusterIPs: true, 8539 prove: prove(proveNumFamilies(2)), 8540 }, 8541 }, { 8542 name: "policy:require_families:single_ips:dual", 8543 line: line(), 8544 create: svcTestCase{ 8545 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8546 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8547 svctest.SetClusterIPs("2000::1")), 8548 expectClusterIPs: true, 8549 prove: prove(proveNumFamilies(1)), 8550 }, 8551 update: svcTestCase{ 8552 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8553 svctest.SetSelector(map[string]string{"k2": "v2"}), 8554 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 8555 svctest.SetIPFamilies(api.IPv6Protocol), 8556 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 8557 expectClusterIPs: true, 8558 prove: prove(proveNumFamilies(2)), 8559 }, 8560 }, { 8561 name: "policy:require_families:dual_ips:nil", 8562 line: line(), 8563 create: svcTestCase{ 8564 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8565 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8566 svctest.SetClusterIPs("2000::1")), 8567 expectClusterIPs: true, 8568 prove: prove(proveNumFamilies(1)), 8569 }, 8570 update: svcTestCase{ 8571 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8572 svctest.SetSelector(map[string]string{"k2": "v2"}), 8573 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 8574 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 8575 expectClusterIPs: true, 8576 prove: prove(proveNumFamilies(2)), 8577 }, 8578 }, { 8579 name: "policy:require_families:dual_ips:single", 8580 line: line(), 8581 create: svcTestCase{ 8582 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8583 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8584 svctest.SetClusterIPs("2000::1")), 8585 expectClusterIPs: true, 8586 prove: prove(proveNumFamilies(1)), 8587 }, 8588 update: svcTestCase{ 8589 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8590 svctest.SetSelector(map[string]string{"k2": "v2"}), 8591 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 8592 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol), 8593 svctest.SetClusterIPs("2000::1")), 8594 expectClusterIPs: true, 8595 prove: prove(proveNumFamilies(2)), 8596 }, 8597 }, { 8598 name: "policy:require_families:dual_ips:dual", 8599 line: line(), 8600 create: svcTestCase{ 8601 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8602 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8603 svctest.SetClusterIPs("2000::1")), 8604 expectClusterIPs: true, 8605 prove: prove(proveNumFamilies(1)), 8606 }, 8607 update: svcTestCase{ 8608 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8609 svctest.SetSelector(map[string]string{"k2": "v2"}), 8610 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 8611 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol), 8612 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 8613 expectClusterIPs: true, 8614 prove: prove(proveNumFamilies(2)), 8615 }, 8616 }, { 8617 name: "single-dual_wrong_order_families", 8618 line: line(), 8619 create: svcTestCase{ 8620 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8621 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8622 svctest.SetClusterIPs("2000::1")), 8623 expectClusterIPs: true, 8624 prove: prove(proveNumFamilies(1)), 8625 }, 8626 update: svcTestCase{ 8627 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8628 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 8629 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 8630 expectError: true, 8631 }, 8632 }, { 8633 name: "single-dual_wrong_order_ips", 8634 line: line(), 8635 create: svcTestCase{ 8636 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8637 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8638 svctest.SetClusterIPs("2000::1")), 8639 expectClusterIPs: true, 8640 prove: prove(proveNumFamilies(1)), 8641 }, 8642 update: svcTestCase{ 8643 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8644 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 8645 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 8646 expectError: true, 8647 }, 8648 }, { 8649 name: "single-dual_ip_in_use", 8650 line: line(), 8651 create: svcTestCase{ 8652 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8653 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8654 svctest.SetClusterIPs("2000::1")), 8655 expectClusterIPs: true, 8656 prove: prove(proveNumFamilies(1)), 8657 }, 8658 beforeUpdate: func(t *testing.T, storage *wrapperRESTForTests) { 8659 alloc := storage.alloc.serviceIPAllocatorsByFamily[api.IPv4Protocol] 8660 ip := "10.0.0.1" 8661 if err := alloc.Allocate(netutils.ParseIPSloppy(ip)); err != nil { 8662 t.Fatalf("test is incorrect, unable to preallocate IP %q: %v", ip, err) 8663 } 8664 }, 8665 update: svcTestCase{ 8666 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8667 svctest.SetSelector(map[string]string{"k2": "v2"}), 8668 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 8669 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol), 8670 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 8671 expectError: true, 8672 }, 8673 }} 8674 8675 t.Run("dualstack:v6v4", func(t *testing.T) { 8676 helpTestCreateUpdateDeleteWithFamilies(t, testCasesV6V4, []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}) 8677 }) 8678 8679 // Headless cases: Covers the full matrix of: 8680 // policy={nil, single, prefer, require} 8681 // families={nil, single, dual} 8682 testCasesHeadless := []cudTestCase{{ 8683 name: "policy:nil_families:nil", 8684 line: line(), 8685 create: svcTestCase{ 8686 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8687 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8688 svctest.SetClusterIPs(api.ClusterIPNone)), 8689 expectHeadless: true, 8690 prove: prove(proveNumFamilies(1)), 8691 }, 8692 update: svcTestCase{ 8693 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8694 svctest.SetSelector(map[string]string{"k2": "v2"})), 8695 expectHeadless: true, 8696 prove: prove(proveNumFamilies(1)), 8697 }, 8698 }, { 8699 name: "policy:nil_families:single", 8700 line: line(), 8701 create: svcTestCase{ 8702 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8703 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8704 svctest.SetClusterIPs(api.ClusterIPNone)), 8705 expectHeadless: true, 8706 prove: prove(proveNumFamilies(1)), 8707 }, 8708 update: svcTestCase{ 8709 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8710 svctest.SetSelector(map[string]string{"k2": "v2"}), 8711 svctest.SetIPFamilies("IPv4")), 8712 expectHeadless: true, 8713 prove: prove(proveNumFamilies(1)), 8714 }, 8715 }, { 8716 name: "policy:nil_families:dual", 8717 line: line(), 8718 create: svcTestCase{ 8719 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8720 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8721 svctest.SetClusterIPs(api.ClusterIPNone)), 8722 expectHeadless: true, 8723 prove: prove(proveNumFamilies(1)), 8724 }, 8725 update: svcTestCase{ 8726 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8727 svctest.SetSelector(map[string]string{"k2": "v2"}), 8728 svctest.SetIPFamilies("IPv4", "IPv6")), 8729 expectError: true, 8730 }, 8731 }, { 8732 name: "policy:single_families:nil", 8733 line: line(), 8734 create: svcTestCase{ 8735 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8736 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8737 svctest.SetClusterIPs(api.ClusterIPNone)), 8738 expectHeadless: true, 8739 prove: prove(proveNumFamilies(1)), 8740 }, 8741 update: svcTestCase{ 8742 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8743 svctest.SetSelector(map[string]string{"k2": "v2"}), 8744 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack)), 8745 expectHeadless: true, 8746 prove: prove(proveNumFamilies(1)), 8747 }, 8748 }, { 8749 name: "policy:single_families:single", 8750 line: line(), 8751 create: svcTestCase{ 8752 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8753 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8754 svctest.SetClusterIPs(api.ClusterIPNone)), 8755 expectHeadless: true, 8756 prove: prove(proveNumFamilies(1)), 8757 }, 8758 update: svcTestCase{ 8759 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8760 svctest.SetSelector(map[string]string{"k2": "v2"}), 8761 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8762 svctest.SetIPFamilies("IPv4")), 8763 expectHeadless: true, 8764 prove: prove(proveNumFamilies(1)), 8765 }, 8766 }, { 8767 name: "policy:single_families:dual", 8768 line: line(), 8769 create: svcTestCase{ 8770 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8771 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8772 svctest.SetClusterIPs(api.ClusterIPNone)), 8773 expectHeadless: true, 8774 prove: prove(proveNumFamilies(1)), 8775 }, 8776 update: svcTestCase{ 8777 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8778 svctest.SetSelector(map[string]string{"k2": "v2"}), 8779 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8780 svctest.SetIPFamilies("IPv4", "IPv6")), 8781 expectError: true, 8782 }, 8783 }, { 8784 name: "policy:prefer_families:nil", 8785 line: line(), 8786 create: svcTestCase{ 8787 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8788 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8789 svctest.SetClusterIPs(api.ClusterIPNone)), 8790 expectHeadless: true, 8791 prove: prove(proveNumFamilies(1)), 8792 }, 8793 update: svcTestCase{ 8794 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8795 svctest.SetSelector(map[string]string{"k2": "v2"}), 8796 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack)), 8797 expectHeadless: true, 8798 prove: prove(proveNumFamilies(2)), 8799 }, 8800 }, { 8801 name: "policy:prefer_families:single", 8802 line: line(), 8803 create: svcTestCase{ 8804 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8805 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8806 svctest.SetClusterIPs(api.ClusterIPNone)), 8807 expectHeadless: true, 8808 prove: prove(proveNumFamilies(1)), 8809 }, 8810 update: svcTestCase{ 8811 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8812 svctest.SetSelector(map[string]string{"k2": "v2"}), 8813 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 8814 svctest.SetIPFamilies("IPv4")), 8815 expectHeadless: true, 8816 prove: prove(proveNumFamilies(2)), 8817 }, 8818 }, { 8819 name: "policy:prefer_families:dual", 8820 line: line(), 8821 create: svcTestCase{ 8822 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8823 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8824 svctest.SetClusterIPs(api.ClusterIPNone)), 8825 expectHeadless: true, 8826 prove: prove(proveNumFamilies(1)), 8827 }, 8828 update: svcTestCase{ 8829 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8830 svctest.SetSelector(map[string]string{"k2": "v2"}), 8831 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 8832 svctest.SetIPFamilies("IPv4", "IPv6")), 8833 expectHeadless: true, 8834 prove: prove(proveNumFamilies(2)), 8835 }, 8836 }, { 8837 name: "policy:require_families:nil", 8838 line: line(), 8839 create: svcTestCase{ 8840 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8841 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8842 svctest.SetClusterIPs(api.ClusterIPNone)), 8843 expectHeadless: true, 8844 prove: prove(proveNumFamilies(1)), 8845 }, 8846 update: svcTestCase{ 8847 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8848 svctest.SetSelector(map[string]string{"k2": "v2"}), 8849 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack)), 8850 expectHeadless: true, 8851 prove: prove(proveNumFamilies(2)), 8852 }, 8853 }, { 8854 name: "policy:require_families:single", 8855 line: line(), 8856 create: svcTestCase{ 8857 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8858 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8859 svctest.SetClusterIPs(api.ClusterIPNone)), 8860 expectHeadless: true, 8861 prove: prove(proveNumFamilies(1)), 8862 }, 8863 update: svcTestCase{ 8864 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8865 svctest.SetSelector(map[string]string{"k2": "v2"}), 8866 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 8867 svctest.SetIPFamilies("IPv4")), 8868 expectHeadless: true, 8869 prove: prove(proveNumFamilies(2)), 8870 }, 8871 }, { 8872 name: "policy:require_families:dual", 8873 line: line(), 8874 create: svcTestCase{ 8875 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8876 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 8877 svctest.SetClusterIPs(api.ClusterIPNone)), 8878 expectHeadless: true, 8879 prove: prove(proveNumFamilies(1)), 8880 }, 8881 update: svcTestCase{ 8882 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8883 svctest.SetSelector(map[string]string{"k2": "v2"}), 8884 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 8885 svctest.SetIPFamilies("IPv4", "IPv6")), 8886 expectHeadless: true, 8887 prove: prove(proveNumFamilies(2)), 8888 }, 8889 }} 8890 8891 t.Run("headless", func(t *testing.T) { 8892 helpTestCreateUpdateDeleteWithFamilies(t, testCasesHeadless, []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}) 8893 }) 8894 } 8895 8896 // Proves that updates from dual-stack. 8897 func TestUpdateIPsFromDualStack(t *testing.T) { 8898 prove := func(proofs ...svcTestProof) []svcTestProof { 8899 return proofs 8900 } 8901 proveNumFamilies := func(n int) svcTestProof { 8902 return func(t *testing.T, storage *wrapperRESTForTests, before, after *api.Service) { 8903 t.Helper() 8904 if got := len(after.Spec.IPFamilies); got != n { 8905 t.Errorf("wrong number of ipFamilies: expected %d, got %d", n, got) 8906 } 8907 } 8908 } 8909 8910 // Dual-stack v4,v6 cases: Covers the full matrix of: 8911 // policy={nil, single, prefer, require} 8912 // families={nil, single, dual} 8913 // ips={nil, single, dual} 8914 testCasesV4V6 := []cudTestCase{{ 8915 name: "policy:nil_families:nil_ips:nil", 8916 line: line(), 8917 create: svcTestCase{ 8918 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8919 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 8920 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 8921 expectClusterIPs: true, 8922 prove: prove(proveNumFamilies(2)), 8923 }, 8924 update: svcTestCase{ 8925 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8926 svctest.SetSelector(map[string]string{"k2": "v2"})), 8927 expectClusterIPs: true, 8928 prove: prove(proveNumFamilies(2)), 8929 }, 8930 }, { 8931 name: "policy:nil_families:nil_ips:single", 8932 line: line(), 8933 create: svcTestCase{ 8934 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8935 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 8936 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 8937 expectClusterIPs: true, 8938 prove: prove(proveNumFamilies(2)), 8939 }, 8940 update: svcTestCase{ 8941 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8942 svctest.SetSelector(map[string]string{"k2": "v2"}), 8943 svctest.SetClusterIPs("10.0.0.1")), 8944 expectError: true, 8945 }, 8946 }, { 8947 name: "policy:nil_families:nil_ips:dual", 8948 line: line(), 8949 create: svcTestCase{ 8950 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8951 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 8952 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 8953 expectClusterIPs: true, 8954 prove: prove(proveNumFamilies(2)), 8955 }, 8956 update: svcTestCase{ 8957 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8958 svctest.SetSelector(map[string]string{"k2": "v2"}), 8959 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 8960 expectClusterIPs: true, 8961 prove: prove(proveNumFamilies(2)), 8962 }, 8963 }, { 8964 name: "policy:nil_families:single_ips:nil", 8965 line: line(), 8966 create: svcTestCase{ 8967 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8968 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 8969 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 8970 expectClusterIPs: true, 8971 prove: prove(proveNumFamilies(2)), 8972 }, 8973 update: svcTestCase{ 8974 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8975 svctest.SetSelector(map[string]string{"k2": "v2"}), 8976 svctest.SetIPFamilies(api.IPv4Protocol)), 8977 expectError: true, 8978 }, 8979 }, { 8980 name: "policy:nil_families:single_ips:single", 8981 line: line(), 8982 create: svcTestCase{ 8983 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8984 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 8985 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 8986 expectClusterIPs: true, 8987 prove: prove(proveNumFamilies(2)), 8988 }, 8989 update: svcTestCase{ 8990 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 8991 svctest.SetSelector(map[string]string{"k2": "v2"}), 8992 svctest.SetIPFamilies(api.IPv4Protocol), 8993 svctest.SetClusterIPs("10.0.0.1")), 8994 expectError: true, 8995 }, 8996 }, { 8997 name: "policy:nil_families:single_ips:dual", 8998 line: line(), 8999 create: svcTestCase{ 9000 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9001 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9002 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9003 expectClusterIPs: true, 9004 prove: prove(proveNumFamilies(2)), 9005 }, 9006 update: svcTestCase{ 9007 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9008 svctest.SetSelector(map[string]string{"k2": "v2"}), 9009 svctest.SetIPFamilies(api.IPv4Protocol), 9010 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9011 expectError: true, 9012 }, 9013 }, { 9014 name: "policy:nil_families:dual_ips:nil", 9015 line: line(), 9016 create: svcTestCase{ 9017 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9018 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9019 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9020 expectClusterIPs: true, 9021 prove: prove(proveNumFamilies(2)), 9022 }, 9023 update: svcTestCase{ 9024 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9025 svctest.SetSelector(map[string]string{"k2": "v2"}), 9026 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 9027 expectClusterIPs: true, 9028 prove: prove(proveNumFamilies(2)), 9029 }, 9030 }, { 9031 name: "policy:nil_families:dual_ips:single", 9032 line: line(), 9033 create: svcTestCase{ 9034 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9035 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9036 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9037 expectClusterIPs: true, 9038 prove: prove(proveNumFamilies(2)), 9039 }, 9040 update: svcTestCase{ 9041 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9042 svctest.SetSelector(map[string]string{"k2": "v2"}), 9043 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol), 9044 svctest.SetClusterIPs("10.0.0.1")), 9045 expectError: true, 9046 }, 9047 }, { 9048 name: "policy:nil_families:dual_ips:dual", 9049 line: line(), 9050 create: svcTestCase{ 9051 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9052 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9053 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9054 expectClusterIPs: true, 9055 prove: prove(proveNumFamilies(2)), 9056 }, 9057 update: svcTestCase{ 9058 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9059 svctest.SetSelector(map[string]string{"k2": "v2"}), 9060 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol), 9061 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9062 expectClusterIPs: true, 9063 prove: prove(proveNumFamilies(2)), 9064 }, 9065 }, { 9066 name: "policy:single_families:nil_ips:nil", 9067 line: line(), 9068 create: svcTestCase{ 9069 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9070 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9071 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9072 expectClusterIPs: true, 9073 prove: prove(proveNumFamilies(2)), 9074 }, 9075 update: svcTestCase{ 9076 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9077 svctest.SetSelector(map[string]string{"k2": "v2"}), 9078 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack)), 9079 expectClusterIPs: true, 9080 prove: prove(proveNumFamilies(1)), 9081 }, 9082 }, { 9083 name: "policy:single_families:nil_ips:single", 9084 line: line(), 9085 create: svcTestCase{ 9086 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9087 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9088 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9089 expectClusterIPs: true, 9090 prove: prove(proveNumFamilies(2)), 9091 }, 9092 update: svcTestCase{ 9093 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9094 svctest.SetSelector(map[string]string{"k2": "v2"}), 9095 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 9096 svctest.SetClusterIPs("10.0.0.1")), 9097 expectClusterIPs: true, 9098 prove: prove(proveNumFamilies(1)), 9099 }, 9100 }, { 9101 name: "policy:single_families:nil_ips:dual", 9102 line: line(), 9103 create: svcTestCase{ 9104 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9105 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9106 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9107 expectClusterIPs: true, 9108 prove: prove(proveNumFamilies(2)), 9109 }, 9110 update: svcTestCase{ 9111 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9112 svctest.SetSelector(map[string]string{"k2": "v2"}), 9113 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 9114 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9115 expectClusterIPs: true, 9116 expectStackDowngrade: true, 9117 prove: prove(proveNumFamilies(1)), 9118 }, 9119 }, { 9120 name: "policy:single_families:single_ips:nil", 9121 line: line(), 9122 create: svcTestCase{ 9123 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9124 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9125 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9126 expectClusterIPs: true, 9127 prove: prove(proveNumFamilies(2)), 9128 }, 9129 update: svcTestCase{ 9130 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9131 svctest.SetSelector(map[string]string{"k2": "v2"}), 9132 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 9133 svctest.SetIPFamilies(api.IPv4Protocol)), 9134 expectClusterIPs: true, 9135 prove: prove(proveNumFamilies(1)), 9136 }, 9137 }, { 9138 name: "policy:single_families:single_ips:single", 9139 line: line(), 9140 create: svcTestCase{ 9141 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9142 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9143 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9144 expectClusterIPs: true, 9145 prove: prove(proveNumFamilies(2)), 9146 }, 9147 update: svcTestCase{ 9148 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9149 svctest.SetSelector(map[string]string{"k2": "v2"}), 9150 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 9151 svctest.SetIPFamilies(api.IPv4Protocol), 9152 svctest.SetClusterIPs("10.0.0.1")), 9153 expectClusterIPs: true, 9154 prove: prove(proveNumFamilies(1)), 9155 }, 9156 }, { 9157 name: "policy:single_families:single_ips:dual", 9158 line: line(), 9159 create: svcTestCase{ 9160 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9161 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9162 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9163 expectClusterIPs: true, 9164 prove: prove(proveNumFamilies(2)), 9165 }, 9166 update: svcTestCase{ 9167 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9168 svctest.SetSelector(map[string]string{"k2": "v2"}), 9169 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 9170 svctest.SetIPFamilies(api.IPv4Protocol), 9171 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9172 expectClusterIPs: true, 9173 expectStackDowngrade: true, 9174 prove: prove(proveNumFamilies(1)), 9175 }, 9176 }, { 9177 name: "policy:single_families:dual_ips:nil", 9178 line: line(), 9179 create: svcTestCase{ 9180 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9181 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9182 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9183 expectClusterIPs: true, 9184 prove: prove(proveNumFamilies(2)), 9185 }, 9186 update: svcTestCase{ 9187 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9188 svctest.SetSelector(map[string]string{"k2": "v2"}), 9189 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 9190 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 9191 expectClusterIPs: true, 9192 expectStackDowngrade: true, 9193 prove: prove(proveNumFamilies(1)), 9194 }, 9195 }, { 9196 name: "policy:single_families:dual_ips:single", 9197 line: line(), 9198 create: svcTestCase{ 9199 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9200 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9201 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9202 expectClusterIPs: true, 9203 prove: prove(proveNumFamilies(2)), 9204 }, 9205 update: svcTestCase{ 9206 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9207 svctest.SetSelector(map[string]string{"k2": "v2"}), 9208 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 9209 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol), 9210 svctest.SetClusterIPs("10.0.0.1")), 9211 expectClusterIPs: true, 9212 expectStackDowngrade: true, 9213 prove: prove(proveNumFamilies(1)), 9214 }, 9215 }, { 9216 name: "policy:single_families:dual_ips:dual", 9217 line: line(), 9218 create: svcTestCase{ 9219 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9220 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9221 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9222 expectClusterIPs: true, 9223 prove: prove(proveNumFamilies(2)), 9224 }, 9225 update: svcTestCase{ 9226 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9227 svctest.SetSelector(map[string]string{"k2": "v2"}), 9228 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 9229 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol), 9230 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9231 expectClusterIPs: true, 9232 expectStackDowngrade: true, 9233 prove: prove(proveNumFamilies(1)), 9234 }, 9235 }, { 9236 name: "policy:prefer_families:nil_ips:nil", 9237 line: line(), 9238 create: svcTestCase{ 9239 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9240 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9241 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9242 expectClusterIPs: true, 9243 prove: prove(proveNumFamilies(2)), 9244 }, 9245 update: svcTestCase{ 9246 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9247 svctest.SetSelector(map[string]string{"k2": "v2"}), 9248 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack)), 9249 expectClusterIPs: true, 9250 prove: prove(proveNumFamilies(2)), 9251 }, 9252 }, { 9253 name: "policy:prefer_families:nil_ips:single", 9254 line: line(), 9255 create: svcTestCase{ 9256 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9257 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9258 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9259 expectClusterIPs: true, 9260 prove: prove(proveNumFamilies(2)), 9261 }, 9262 update: svcTestCase{ 9263 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9264 svctest.SetSelector(map[string]string{"k2": "v2"}), 9265 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 9266 svctest.SetClusterIPs("10.0.0.1")), 9267 expectError: true, 9268 }, 9269 }, { 9270 name: "policy:prefer_families:nil_ips:dual", 9271 line: line(), 9272 create: svcTestCase{ 9273 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9274 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9275 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9276 expectClusterIPs: true, 9277 prove: prove(proveNumFamilies(2)), 9278 }, 9279 update: svcTestCase{ 9280 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9281 svctest.SetSelector(map[string]string{"k2": "v2"}), 9282 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 9283 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9284 expectClusterIPs: true, 9285 prove: prove(proveNumFamilies(2)), 9286 }, 9287 }, { 9288 name: "policy:prefer_families:single_ips:nil", 9289 line: line(), 9290 create: svcTestCase{ 9291 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9292 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9293 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9294 expectClusterIPs: true, 9295 prove: prove(proveNumFamilies(2)), 9296 }, 9297 update: svcTestCase{ 9298 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9299 svctest.SetSelector(map[string]string{"k2": "v2"}), 9300 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 9301 svctest.SetIPFamilies(api.IPv4Protocol)), 9302 expectError: true, 9303 }, 9304 }, { 9305 name: "policy:prefer_families:single_ips:single", 9306 line: line(), 9307 create: svcTestCase{ 9308 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9309 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9310 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9311 expectClusterIPs: true, 9312 prove: prove(proveNumFamilies(2)), 9313 }, 9314 update: svcTestCase{ 9315 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9316 svctest.SetSelector(map[string]string{"k2": "v2"}), 9317 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 9318 svctest.SetIPFamilies(api.IPv4Protocol), 9319 svctest.SetClusterIPs("10.0.0.1")), 9320 expectError: true, 9321 }, 9322 }, { 9323 name: "policy:prefer_families:single_ips:dual", 9324 line: line(), 9325 create: svcTestCase{ 9326 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9327 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9328 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9329 expectClusterIPs: true, 9330 prove: prove(proveNumFamilies(2)), 9331 }, 9332 update: svcTestCase{ 9333 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9334 svctest.SetSelector(map[string]string{"k2": "v2"}), 9335 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 9336 svctest.SetIPFamilies(api.IPv4Protocol), 9337 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9338 expectError: true, 9339 }, 9340 }, { 9341 name: "policy:prefer_families:dual_ips:nil", 9342 line: line(), 9343 create: svcTestCase{ 9344 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9345 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9346 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9347 expectClusterIPs: true, 9348 prove: prove(proveNumFamilies(2)), 9349 }, 9350 update: svcTestCase{ 9351 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9352 svctest.SetSelector(map[string]string{"k2": "v2"}), 9353 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 9354 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 9355 expectClusterIPs: true, 9356 prove: prove(proveNumFamilies(2)), 9357 }, 9358 }, { 9359 name: "policy:prefer_families:dual_ips:single", 9360 line: line(), 9361 create: svcTestCase{ 9362 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9363 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9364 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9365 expectClusterIPs: true, 9366 prove: prove(proveNumFamilies(2)), 9367 }, 9368 update: svcTestCase{ 9369 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9370 svctest.SetSelector(map[string]string{"k2": "v2"}), 9371 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 9372 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol), 9373 svctest.SetClusterIPs("10.0.0.1")), 9374 expectError: true, 9375 }, 9376 }, { 9377 name: "policy:prefer_families:dual_ips:dual", 9378 line: line(), 9379 create: svcTestCase{ 9380 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9381 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9382 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9383 expectClusterIPs: true, 9384 prove: prove(proveNumFamilies(2)), 9385 }, 9386 update: svcTestCase{ 9387 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9388 svctest.SetSelector(map[string]string{"k2": "v2"}), 9389 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 9390 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol), 9391 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9392 expectClusterIPs: true, 9393 prove: prove(proveNumFamilies(2)), 9394 }, 9395 }, { 9396 name: "policy:require_families:nil_ips:nil", 9397 line: line(), 9398 create: svcTestCase{ 9399 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9400 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9401 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9402 expectClusterIPs: true, 9403 prove: prove(proveNumFamilies(2)), 9404 }, 9405 update: svcTestCase{ 9406 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9407 svctest.SetSelector(map[string]string{"k2": "v2"}), 9408 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack)), 9409 expectClusterIPs: true, 9410 prove: prove(proveNumFamilies(2)), 9411 }, 9412 }, { 9413 name: "policy:require_families:nil_ips:single", 9414 line: line(), 9415 create: svcTestCase{ 9416 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9417 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9418 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9419 expectClusterIPs: true, 9420 prove: prove(proveNumFamilies(2)), 9421 }, 9422 update: svcTestCase{ 9423 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9424 svctest.SetSelector(map[string]string{"k2": "v2"}), 9425 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9426 svctest.SetClusterIPs("10.0.0.1")), 9427 expectError: true, 9428 }, 9429 }, { 9430 name: "policy:require_families:nil_ips:dual", 9431 line: line(), 9432 create: svcTestCase{ 9433 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9434 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9435 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9436 expectClusterIPs: true, 9437 prove: prove(proveNumFamilies(2)), 9438 }, 9439 update: svcTestCase{ 9440 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9441 svctest.SetSelector(map[string]string{"k2": "v2"}), 9442 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9443 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9444 expectClusterIPs: true, 9445 prove: prove(proveNumFamilies(2)), 9446 }, 9447 }, { 9448 name: "policy:require_families:single_ips:nil", 9449 line: line(), 9450 create: svcTestCase{ 9451 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9452 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9453 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9454 expectClusterIPs: true, 9455 prove: prove(proveNumFamilies(2)), 9456 }, 9457 update: svcTestCase{ 9458 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9459 svctest.SetSelector(map[string]string{"k2": "v2"}), 9460 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9461 svctest.SetIPFamilies(api.IPv4Protocol)), 9462 expectError: true, 9463 }, 9464 }, { 9465 name: "policy:require_families:single_ips:single", 9466 line: line(), 9467 create: svcTestCase{ 9468 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9469 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9470 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9471 expectClusterIPs: true, 9472 prove: prove(proveNumFamilies(2)), 9473 }, 9474 update: svcTestCase{ 9475 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9476 svctest.SetSelector(map[string]string{"k2": "v2"}), 9477 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9478 svctest.SetIPFamilies(api.IPv4Protocol), 9479 svctest.SetClusterIPs("10.0.0.1")), 9480 expectError: true, 9481 }, 9482 }, { 9483 name: "policy:require_families:single_ips:dual", 9484 line: line(), 9485 create: svcTestCase{ 9486 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9487 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9488 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9489 expectClusterIPs: true, 9490 prove: prove(proveNumFamilies(2)), 9491 }, 9492 update: svcTestCase{ 9493 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9494 svctest.SetSelector(map[string]string{"k2": "v2"}), 9495 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9496 svctest.SetIPFamilies(api.IPv4Protocol), 9497 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9498 expectError: true, 9499 }, 9500 }, { 9501 name: "policy:require_families:dual_ips:nil", 9502 line: line(), 9503 create: svcTestCase{ 9504 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9505 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9506 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9507 expectClusterIPs: true, 9508 prove: prove(proveNumFamilies(2)), 9509 }, 9510 update: svcTestCase{ 9511 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9512 svctest.SetSelector(map[string]string{"k2": "v2"}), 9513 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9514 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)), 9515 expectClusterIPs: true, 9516 prove: prove(proveNumFamilies(2)), 9517 }, 9518 }, { 9519 name: "policy:require_families:dual_ips:single", 9520 line: line(), 9521 create: svcTestCase{ 9522 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9523 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9524 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9525 expectClusterIPs: true, 9526 prove: prove(proveNumFamilies(2)), 9527 }, 9528 update: svcTestCase{ 9529 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9530 svctest.SetSelector(map[string]string{"k2": "v2"}), 9531 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9532 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol), 9533 svctest.SetClusterIPs("10.0.0.1")), 9534 expectError: true, 9535 }, 9536 }, { 9537 name: "policy:require_families:dual_ips:dual", 9538 line: line(), 9539 create: svcTestCase{ 9540 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9541 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9542 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9543 expectClusterIPs: true, 9544 prove: prove(proveNumFamilies(2)), 9545 }, 9546 update: svcTestCase{ 9547 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9548 svctest.SetSelector(map[string]string{"k2": "v2"}), 9549 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9550 svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol), 9551 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9552 expectClusterIPs: true, 9553 prove: prove(proveNumFamilies(2)), 9554 }, 9555 }, { 9556 name: "dual-single_wrong_order_families", 9557 line: line(), 9558 create: svcTestCase{ 9559 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9560 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9561 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9562 expectClusterIPs: true, 9563 prove: prove(proveNumFamilies(2)), 9564 }, 9565 update: svcTestCase{ 9566 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9567 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 9568 svctest.SetIPFamilies(api.IPv6Protocol)), 9569 expectError: true, 9570 }, 9571 }, { 9572 name: "dual-single_wrong_order_ips", 9573 line: line(), 9574 create: svcTestCase{ 9575 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9576 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9577 svctest.SetClusterIPs("10.0.0.1", "2000::1")), 9578 expectClusterIPs: true, 9579 prove: prove(proveNumFamilies(2)), 9580 }, 9581 update: svcTestCase{ 9582 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9583 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 9584 svctest.SetClusterIPs("2000::1")), 9585 expectError: true, 9586 }, 9587 }} 9588 9589 t.Run("dualstack:v4v6", func(t *testing.T) { 9590 helpTestCreateUpdateDeleteWithFamilies(t, testCasesV4V6, []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}) 9591 }) 9592 9593 // Dual-stack v6,v4 cases: Covers the full matrix of: 9594 // policy={nil, single, prefer, require} 9595 // families={nil, single, dual} 9596 // ips={nil, single, dual} 9597 testCasesV6V4 := []cudTestCase{{ 9598 name: "policy:nil_families:nil_ips:nil", 9599 line: line(), 9600 create: svcTestCase{ 9601 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9602 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9603 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 9604 expectClusterIPs: true, 9605 prove: prove(proveNumFamilies(2)), 9606 }, 9607 update: svcTestCase{ 9608 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9609 svctest.SetSelector(map[string]string{"k2": "v2"})), 9610 expectClusterIPs: true, 9611 prove: prove(proveNumFamilies(2)), 9612 }, 9613 }, { 9614 name: "policy:nil_families:nil_ips:single", 9615 line: line(), 9616 create: svcTestCase{ 9617 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9618 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9619 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 9620 expectClusterIPs: true, 9621 prove: prove(proveNumFamilies(2)), 9622 }, 9623 update: svcTestCase{ 9624 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9625 svctest.SetSelector(map[string]string{"k2": "v2"}), 9626 svctest.SetClusterIPs("2000::1")), 9627 expectError: true, 9628 }, 9629 }, { 9630 name: "policy:nil_families:nil_ips:dual", 9631 line: line(), 9632 create: svcTestCase{ 9633 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9634 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9635 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 9636 expectClusterIPs: true, 9637 prove: prove(proveNumFamilies(2)), 9638 }, 9639 update: svcTestCase{ 9640 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9641 svctest.SetSelector(map[string]string{"k2": "v2"}), 9642 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 9643 expectClusterIPs: true, 9644 prove: prove(proveNumFamilies(2)), 9645 }, 9646 }, { 9647 name: "policy:nil_families:single_ips:nil", 9648 line: line(), 9649 create: svcTestCase{ 9650 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9651 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9652 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 9653 expectClusterIPs: true, 9654 prove: prove(proveNumFamilies(2)), 9655 }, 9656 update: svcTestCase{ 9657 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9658 svctest.SetSelector(map[string]string{"k2": "v2"}), 9659 svctest.SetIPFamilies(api.IPv6Protocol)), 9660 expectError: true, 9661 }, 9662 }, { 9663 name: "policy:nil_families:single_ips:single", 9664 line: line(), 9665 create: svcTestCase{ 9666 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9667 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9668 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 9669 expectClusterIPs: true, 9670 prove: prove(proveNumFamilies(2)), 9671 }, 9672 update: svcTestCase{ 9673 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9674 svctest.SetSelector(map[string]string{"k2": "v2"}), 9675 svctest.SetIPFamilies(api.IPv6Protocol), 9676 svctest.SetClusterIPs("2000::1")), 9677 expectError: true, 9678 }, 9679 }, { 9680 name: "policy:nil_families:single_ips:dual", 9681 line: line(), 9682 create: svcTestCase{ 9683 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9684 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9685 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 9686 expectClusterIPs: true, 9687 prove: prove(proveNumFamilies(2)), 9688 }, 9689 update: svcTestCase{ 9690 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9691 svctest.SetSelector(map[string]string{"k2": "v2"}), 9692 svctest.SetIPFamilies(api.IPv6Protocol), 9693 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 9694 expectError: true, 9695 }, 9696 }, { 9697 name: "policy:nil_families:dual_ips:nil", 9698 line: line(), 9699 create: svcTestCase{ 9700 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9701 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9702 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 9703 expectClusterIPs: true, 9704 prove: prove(proveNumFamilies(2)), 9705 }, 9706 update: svcTestCase{ 9707 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9708 svctest.SetSelector(map[string]string{"k2": "v2"}), 9709 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 9710 expectClusterIPs: true, 9711 prove: prove(proveNumFamilies(2)), 9712 }, 9713 }, { 9714 name: "policy:nil_families:dual_ips:single", 9715 line: line(), 9716 create: svcTestCase{ 9717 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9718 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9719 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 9720 expectClusterIPs: true, 9721 prove: prove(proveNumFamilies(2)), 9722 }, 9723 update: svcTestCase{ 9724 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9725 svctest.SetSelector(map[string]string{"k2": "v2"}), 9726 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol), 9727 svctest.SetClusterIPs("2000::1")), 9728 expectError: true, 9729 }, 9730 }, { 9731 name: "policy:nil_families:dual_ips:dual", 9732 line: line(), 9733 create: svcTestCase{ 9734 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9735 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9736 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 9737 expectClusterIPs: true, 9738 prove: prove(proveNumFamilies(2)), 9739 }, 9740 update: svcTestCase{ 9741 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9742 svctest.SetSelector(map[string]string{"k2": "v2"}), 9743 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol), 9744 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 9745 expectClusterIPs: true, 9746 prove: prove(proveNumFamilies(2)), 9747 }, 9748 }, { 9749 name: "policy:single_families:nil_ips:nil", 9750 line: line(), 9751 create: svcTestCase{ 9752 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9753 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9754 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 9755 expectClusterIPs: true, 9756 prove: prove(proveNumFamilies(2)), 9757 }, 9758 update: svcTestCase{ 9759 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9760 svctest.SetSelector(map[string]string{"k2": "v2"}), 9761 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack)), 9762 expectClusterIPs: true, 9763 prove: prove(proveNumFamilies(1)), 9764 }, 9765 }, { 9766 name: "policy:single_families:nil_ips:single", 9767 line: line(), 9768 create: svcTestCase{ 9769 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9770 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9771 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 9772 expectClusterIPs: true, 9773 prove: prove(proveNumFamilies(2)), 9774 }, 9775 update: svcTestCase{ 9776 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9777 svctest.SetSelector(map[string]string{"k2": "v2"}), 9778 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 9779 svctest.SetClusterIPs("2000::1")), 9780 expectClusterIPs: true, 9781 prove: prove(proveNumFamilies(1)), 9782 }, 9783 }, { 9784 name: "policy:single_families:nil_ips:dual", 9785 line: line(), 9786 create: svcTestCase{ 9787 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9788 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9789 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 9790 expectClusterIPs: true, 9791 prove: prove(proveNumFamilies(2)), 9792 }, 9793 update: svcTestCase{ 9794 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9795 svctest.SetSelector(map[string]string{"k2": "v2"}), 9796 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 9797 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 9798 expectClusterIPs: true, 9799 expectStackDowngrade: true, 9800 prove: prove(proveNumFamilies(1)), 9801 }, 9802 }, { 9803 name: "policy:single_families:single_ips:nil", 9804 line: line(), 9805 create: svcTestCase{ 9806 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9807 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9808 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 9809 expectClusterIPs: true, 9810 prove: prove(proveNumFamilies(2)), 9811 }, 9812 update: svcTestCase{ 9813 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9814 svctest.SetSelector(map[string]string{"k2": "v2"}), 9815 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 9816 svctest.SetIPFamilies(api.IPv6Protocol)), 9817 expectClusterIPs: true, 9818 prove: prove(proveNumFamilies(1)), 9819 }, 9820 }, { 9821 name: "policy:single_families:single_ips:single", 9822 line: line(), 9823 create: svcTestCase{ 9824 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9825 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9826 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 9827 expectClusterIPs: true, 9828 prove: prove(proveNumFamilies(2)), 9829 }, 9830 update: svcTestCase{ 9831 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9832 svctest.SetSelector(map[string]string{"k2": "v2"}), 9833 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 9834 svctest.SetIPFamilies(api.IPv6Protocol), 9835 svctest.SetClusterIPs("2000::1")), 9836 expectClusterIPs: true, 9837 prove: prove(proveNumFamilies(1)), 9838 }, 9839 }, { 9840 name: "policy:single_families:single_ips:dual", 9841 line: line(), 9842 create: svcTestCase{ 9843 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9844 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9845 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 9846 expectClusterIPs: true, 9847 prove: prove(proveNumFamilies(2)), 9848 }, 9849 update: svcTestCase{ 9850 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9851 svctest.SetSelector(map[string]string{"k2": "v2"}), 9852 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 9853 svctest.SetIPFamilies(api.IPv6Protocol), 9854 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 9855 expectClusterIPs: true, 9856 expectStackDowngrade: true, 9857 prove: prove(proveNumFamilies(1)), 9858 }, 9859 }, { 9860 name: "policy:single_families:dual_ips:nil", 9861 line: line(), 9862 create: svcTestCase{ 9863 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9864 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9865 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 9866 expectClusterIPs: true, 9867 prove: prove(proveNumFamilies(2)), 9868 }, 9869 update: svcTestCase{ 9870 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9871 svctest.SetSelector(map[string]string{"k2": "v2"}), 9872 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 9873 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 9874 expectClusterIPs: true, 9875 expectStackDowngrade: true, 9876 prove: prove(proveNumFamilies(1)), 9877 }, 9878 }, { 9879 name: "policy:single_families:dual_ips:single", 9880 line: line(), 9881 create: svcTestCase{ 9882 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9883 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9884 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 9885 expectClusterIPs: true, 9886 prove: prove(proveNumFamilies(2)), 9887 }, 9888 update: svcTestCase{ 9889 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9890 svctest.SetSelector(map[string]string{"k2": "v2"}), 9891 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 9892 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol), 9893 svctest.SetClusterIPs("2000::1")), 9894 expectClusterIPs: true, 9895 expectStackDowngrade: true, 9896 prove: prove(proveNumFamilies(1)), 9897 }, 9898 }, { 9899 name: "policy:single_families:dual_ips:dual", 9900 line: line(), 9901 create: svcTestCase{ 9902 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9903 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9904 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 9905 expectClusterIPs: true, 9906 prove: prove(proveNumFamilies(2)), 9907 }, 9908 update: svcTestCase{ 9909 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9910 svctest.SetSelector(map[string]string{"k2": "v2"}), 9911 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 9912 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol), 9913 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 9914 expectClusterIPs: true, 9915 expectStackDowngrade: true, 9916 prove: prove(proveNumFamilies(1)), 9917 }, 9918 }, { 9919 name: "policy:prefer_families:nil_ips:nil", 9920 line: line(), 9921 create: svcTestCase{ 9922 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9923 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9924 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 9925 expectClusterIPs: true, 9926 prove: prove(proveNumFamilies(2)), 9927 }, 9928 update: svcTestCase{ 9929 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9930 svctest.SetSelector(map[string]string{"k2": "v2"}), 9931 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack)), 9932 expectClusterIPs: true, 9933 prove: prove(proveNumFamilies(2)), 9934 }, 9935 }, { 9936 name: "policy:prefer_families:nil_ips:single", 9937 line: line(), 9938 create: svcTestCase{ 9939 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9940 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9941 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 9942 expectClusterIPs: true, 9943 prove: prove(proveNumFamilies(2)), 9944 }, 9945 update: svcTestCase{ 9946 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9947 svctest.SetSelector(map[string]string{"k2": "v2"}), 9948 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 9949 svctest.SetClusterIPs("2000::1")), 9950 expectError: true, 9951 }, 9952 }, { 9953 name: "policy:prefer_families:nil_ips:dual", 9954 line: line(), 9955 create: svcTestCase{ 9956 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9957 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9958 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 9959 expectClusterIPs: true, 9960 prove: prove(proveNumFamilies(2)), 9961 }, 9962 update: svcTestCase{ 9963 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9964 svctest.SetSelector(map[string]string{"k2": "v2"}), 9965 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 9966 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 9967 expectClusterIPs: true, 9968 prove: prove(proveNumFamilies(2)), 9969 }, 9970 }, { 9971 name: "policy:prefer_families:single_ips:nil", 9972 line: line(), 9973 create: svcTestCase{ 9974 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9975 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9976 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 9977 expectClusterIPs: true, 9978 prove: prove(proveNumFamilies(2)), 9979 }, 9980 update: svcTestCase{ 9981 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9982 svctest.SetSelector(map[string]string{"k2": "v2"}), 9983 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 9984 svctest.SetIPFamilies(api.IPv6Protocol)), 9985 expectError: true, 9986 }, 9987 }, { 9988 name: "policy:prefer_families:single_ips:single", 9989 line: line(), 9990 create: svcTestCase{ 9991 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9992 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 9993 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 9994 expectClusterIPs: true, 9995 prove: prove(proveNumFamilies(2)), 9996 }, 9997 update: svcTestCase{ 9998 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 9999 svctest.SetSelector(map[string]string{"k2": "v2"}), 10000 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 10001 svctest.SetIPFamilies(api.IPv6Protocol), 10002 svctest.SetClusterIPs("2000::1")), 10003 expectError: true, 10004 }, 10005 }, { 10006 name: "policy:prefer_families:single_ips:dual", 10007 line: line(), 10008 create: svcTestCase{ 10009 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10010 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 10011 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 10012 expectClusterIPs: true, 10013 prove: prove(proveNumFamilies(2)), 10014 }, 10015 update: svcTestCase{ 10016 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10017 svctest.SetSelector(map[string]string{"k2": "v2"}), 10018 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 10019 svctest.SetIPFamilies(api.IPv6Protocol), 10020 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 10021 expectError: true, 10022 }, 10023 }, { 10024 name: "policy:prefer_families:dual_ips:nil", 10025 line: line(), 10026 create: svcTestCase{ 10027 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10028 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 10029 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 10030 expectClusterIPs: true, 10031 prove: prove(proveNumFamilies(2)), 10032 }, 10033 update: svcTestCase{ 10034 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10035 svctest.SetSelector(map[string]string{"k2": "v2"}), 10036 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 10037 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 10038 expectClusterIPs: true, 10039 prove: prove(proveNumFamilies(2)), 10040 }, 10041 }, { 10042 name: "policy:prefer_families:dual_ips:single", 10043 line: line(), 10044 create: svcTestCase{ 10045 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10046 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 10047 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 10048 expectClusterIPs: true, 10049 prove: prove(proveNumFamilies(2)), 10050 }, 10051 update: svcTestCase{ 10052 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10053 svctest.SetSelector(map[string]string{"k2": "v2"}), 10054 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 10055 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol), 10056 svctest.SetClusterIPs("2000::1")), 10057 expectError: true, 10058 }, 10059 }, { 10060 name: "policy:prefer_families:dual_ips:dual", 10061 line: line(), 10062 create: svcTestCase{ 10063 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10064 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 10065 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 10066 expectClusterIPs: true, 10067 prove: prove(proveNumFamilies(2)), 10068 }, 10069 update: svcTestCase{ 10070 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10071 svctest.SetSelector(map[string]string{"k2": "v2"}), 10072 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 10073 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol), 10074 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 10075 expectClusterIPs: true, 10076 prove: prove(proveNumFamilies(2)), 10077 }, 10078 }, { 10079 name: "policy:require_families:nil_ips:nil", 10080 line: line(), 10081 create: svcTestCase{ 10082 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10083 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 10084 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 10085 expectClusterIPs: true, 10086 prove: prove(proveNumFamilies(2)), 10087 }, 10088 update: svcTestCase{ 10089 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10090 svctest.SetSelector(map[string]string{"k2": "v2"}), 10091 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack)), 10092 expectClusterIPs: true, 10093 prove: prove(proveNumFamilies(2)), 10094 }, 10095 }, { 10096 name: "policy:require_families:nil_ips:single", 10097 line: line(), 10098 create: svcTestCase{ 10099 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10100 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 10101 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 10102 expectClusterIPs: true, 10103 prove: prove(proveNumFamilies(2)), 10104 }, 10105 update: svcTestCase{ 10106 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10107 svctest.SetSelector(map[string]string{"k2": "v2"}), 10108 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 10109 svctest.SetClusterIPs("2000::1")), 10110 expectError: true, 10111 }, 10112 }, { 10113 name: "policy:require_families:nil_ips:dual", 10114 line: line(), 10115 create: svcTestCase{ 10116 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10117 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 10118 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 10119 expectClusterIPs: true, 10120 prove: prove(proveNumFamilies(2)), 10121 }, 10122 update: svcTestCase{ 10123 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10124 svctest.SetSelector(map[string]string{"k2": "v2"}), 10125 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 10126 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 10127 expectClusterIPs: true, 10128 prove: prove(proveNumFamilies(2)), 10129 }, 10130 }, { 10131 name: "policy:require_families:single_ips:nil", 10132 line: line(), 10133 create: svcTestCase{ 10134 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10135 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 10136 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 10137 expectClusterIPs: true, 10138 prove: prove(proveNumFamilies(2)), 10139 }, 10140 update: svcTestCase{ 10141 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10142 svctest.SetSelector(map[string]string{"k2": "v2"}), 10143 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 10144 svctest.SetIPFamilies(api.IPv6Protocol)), 10145 expectError: true, 10146 }, 10147 }, { 10148 name: "policy:require_families:single_ips:single", 10149 line: line(), 10150 create: svcTestCase{ 10151 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10152 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 10153 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 10154 expectClusterIPs: true, 10155 prove: prove(proveNumFamilies(2)), 10156 }, 10157 update: svcTestCase{ 10158 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10159 svctest.SetSelector(map[string]string{"k2": "v2"}), 10160 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 10161 svctest.SetIPFamilies(api.IPv6Protocol), 10162 svctest.SetClusterIPs("2000::1")), 10163 expectError: true, 10164 }, 10165 }, { 10166 name: "policy:require_families:single_ips:dual", 10167 line: line(), 10168 create: svcTestCase{ 10169 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10170 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 10171 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 10172 expectClusterIPs: true, 10173 prove: prove(proveNumFamilies(2)), 10174 }, 10175 update: svcTestCase{ 10176 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10177 svctest.SetSelector(map[string]string{"k2": "v2"}), 10178 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 10179 svctest.SetIPFamilies(api.IPv6Protocol), 10180 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 10181 expectError: true, 10182 }, 10183 }, { 10184 name: "policy:require_families:dual_ips:nil", 10185 line: line(), 10186 create: svcTestCase{ 10187 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10188 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 10189 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 10190 expectClusterIPs: true, 10191 prove: prove(proveNumFamilies(2)), 10192 }, 10193 update: svcTestCase{ 10194 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10195 svctest.SetSelector(map[string]string{"k2": "v2"}), 10196 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 10197 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol)), 10198 expectClusterIPs: true, 10199 prove: prove(proveNumFamilies(2)), 10200 }, 10201 }, { 10202 name: "policy:require_families:dual_ips:single", 10203 line: line(), 10204 create: svcTestCase{ 10205 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10206 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 10207 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 10208 expectClusterIPs: true, 10209 prove: prove(proveNumFamilies(2)), 10210 }, 10211 update: svcTestCase{ 10212 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10213 svctest.SetSelector(map[string]string{"k2": "v2"}), 10214 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 10215 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol), 10216 svctest.SetClusterIPs("2000::1")), 10217 expectError: true, 10218 }, 10219 }, { 10220 name: "policy:require_families:dual_ips:dual", 10221 line: line(), 10222 create: svcTestCase{ 10223 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10224 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 10225 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 10226 expectClusterIPs: true, 10227 prove: prove(proveNumFamilies(2)), 10228 }, 10229 update: svcTestCase{ 10230 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10231 svctest.SetSelector(map[string]string{"k2": "v2"}), 10232 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 10233 svctest.SetIPFamilies(api.IPv6Protocol, api.IPv4Protocol), 10234 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 10235 expectClusterIPs: true, 10236 prove: prove(proveNumFamilies(2)), 10237 }, 10238 }, { 10239 name: "dual-single_wrong_order_families", 10240 line: line(), 10241 create: svcTestCase{ 10242 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10243 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 10244 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 10245 expectClusterIPs: true, 10246 prove: prove(proveNumFamilies(2)), 10247 }, 10248 update: svcTestCase{ 10249 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10250 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 10251 svctest.SetIPFamilies(api.IPv4Protocol)), 10252 expectError: true, 10253 }, 10254 }, { 10255 name: "dual-single_wrong_order_ips", 10256 line: line(), 10257 create: svcTestCase{ 10258 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10259 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 10260 svctest.SetClusterIPs("2000::1", "10.0.0.1")), 10261 expectClusterIPs: true, 10262 prove: prove(proveNumFamilies(2)), 10263 }, 10264 update: svcTestCase{ 10265 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10266 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 10267 svctest.SetClusterIPs("10.0.0.1")), 10268 expectError: true, 10269 }, 10270 }} 10271 10272 t.Run("dualstack:v6v4", func(t *testing.T) { 10273 helpTestCreateUpdateDeleteWithFamilies(t, testCasesV6V4, []api.IPFamily{api.IPv6Protocol, api.IPv4Protocol}) 10274 }) 10275 10276 // Headless cases: Covers the full matrix of: 10277 // policy={nil, single, prefer, require} 10278 // families={nil, single, dual} 10279 testCasesHeadless := []cudTestCase{{ 10280 name: "policy:nil_families:nil", 10281 line: line(), 10282 create: svcTestCase{ 10283 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10284 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 10285 svctest.SetClusterIPs(api.ClusterIPNone)), 10286 expectHeadless: true, 10287 prove: prove(proveNumFamilies(2)), 10288 }, 10289 update: svcTestCase{ 10290 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10291 svctest.SetSelector(map[string]string{"k2": "v2"})), 10292 expectHeadless: true, 10293 prove: prove(proveNumFamilies(2)), 10294 }, 10295 }, { 10296 name: "policy:nil_families:single", 10297 line: line(), 10298 create: svcTestCase{ 10299 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10300 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 10301 svctest.SetClusterIPs(api.ClusterIPNone)), 10302 expectHeadless: true, 10303 prove: prove(proveNumFamilies(2)), 10304 }, 10305 update: svcTestCase{ 10306 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10307 svctest.SetSelector(map[string]string{"k2": "v2"}), 10308 svctest.SetIPFamilies("IPv4")), 10309 expectError: true, 10310 }, 10311 }, { 10312 name: "policy:nil_families:dual", 10313 line: line(), 10314 create: svcTestCase{ 10315 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10316 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 10317 svctest.SetClusterIPs(api.ClusterIPNone)), 10318 expectHeadless: true, 10319 prove: prove(proveNumFamilies(2)), 10320 }, 10321 update: svcTestCase{ 10322 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10323 svctest.SetSelector(map[string]string{"k2": "v2"}), 10324 svctest.SetIPFamilies("IPv4", "IPv6")), 10325 expectHeadless: true, 10326 prove: prove(proveNumFamilies(2)), 10327 }, 10328 }, { 10329 name: "policy:single_families:nil", 10330 line: line(), 10331 create: svcTestCase{ 10332 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10333 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 10334 svctest.SetClusterIPs(api.ClusterIPNone)), 10335 expectHeadless: true, 10336 prove: prove(proveNumFamilies(2)), 10337 }, 10338 update: svcTestCase{ 10339 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10340 svctest.SetSelector(map[string]string{"k2": "v2"}), 10341 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack)), 10342 expectHeadless: true, 10343 prove: prove(proveNumFamilies(1)), 10344 }, 10345 }, { 10346 name: "policy:single_families:single", 10347 line: line(), 10348 create: svcTestCase{ 10349 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10350 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 10351 svctest.SetClusterIPs(api.ClusterIPNone)), 10352 expectHeadless: true, 10353 prove: prove(proveNumFamilies(2)), 10354 }, 10355 update: svcTestCase{ 10356 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10357 svctest.SetSelector(map[string]string{"k2": "v2"}), 10358 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 10359 svctest.SetIPFamilies("IPv4")), 10360 expectHeadless: true, 10361 prove: prove(proveNumFamilies(1)), 10362 }, 10363 }, { 10364 name: "policy:single_families:dual", 10365 line: line(), 10366 create: svcTestCase{ 10367 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10368 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 10369 svctest.SetClusterIPs(api.ClusterIPNone)), 10370 expectHeadless: true, 10371 prove: prove(proveNumFamilies(2)), 10372 }, 10373 update: svcTestCase{ 10374 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10375 svctest.SetSelector(map[string]string{"k2": "v2"}), 10376 svctest.SetIPFamilyPolicy(api.IPFamilyPolicySingleStack), 10377 svctest.SetIPFamilies("IPv4", "IPv6")), 10378 expectHeadless: true, 10379 expectStackDowngrade: true, 10380 prove: prove(proveNumFamilies(1)), 10381 }, 10382 }, { 10383 name: "policy:prefer_families:nil", 10384 line: line(), 10385 create: svcTestCase{ 10386 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10387 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 10388 svctest.SetClusterIPs(api.ClusterIPNone)), 10389 expectHeadless: true, 10390 prove: prove(proveNumFamilies(2)), 10391 }, 10392 update: svcTestCase{ 10393 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10394 svctest.SetSelector(map[string]string{"k2": "v2"}), 10395 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack)), 10396 expectHeadless: true, 10397 prove: prove(proveNumFamilies(2)), 10398 }, 10399 }, { 10400 name: "policy:prefer_families:single", 10401 line: line(), 10402 create: svcTestCase{ 10403 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10404 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 10405 svctest.SetClusterIPs(api.ClusterIPNone)), 10406 expectHeadless: true, 10407 prove: prove(proveNumFamilies(2)), 10408 }, 10409 update: svcTestCase{ 10410 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10411 svctest.SetSelector(map[string]string{"k2": "v2"}), 10412 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 10413 svctest.SetIPFamilies("IPv4")), 10414 expectError: true, 10415 }, 10416 }, { 10417 name: "policy:prefer_families:dual", 10418 line: line(), 10419 create: svcTestCase{ 10420 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10421 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 10422 svctest.SetClusterIPs(api.ClusterIPNone)), 10423 expectHeadless: true, 10424 prove: prove(proveNumFamilies(2)), 10425 }, 10426 update: svcTestCase{ 10427 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10428 svctest.SetSelector(map[string]string{"k2": "v2"}), 10429 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 10430 svctest.SetIPFamilies("IPv4", "IPv6")), 10431 expectHeadless: true, 10432 prove: prove(proveNumFamilies(2)), 10433 }, 10434 }, { 10435 name: "policy:require_families:nil", 10436 line: line(), 10437 create: svcTestCase{ 10438 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10439 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 10440 svctest.SetClusterIPs(api.ClusterIPNone)), 10441 expectHeadless: true, 10442 prove: prove(proveNumFamilies(2)), 10443 }, 10444 update: svcTestCase{ 10445 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10446 svctest.SetSelector(map[string]string{"k2": "v2"}), 10447 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack)), 10448 expectHeadless: true, 10449 prove: prove(proveNumFamilies(2)), 10450 }, 10451 }, { 10452 name: "policy:require_families:single", 10453 line: line(), 10454 create: svcTestCase{ 10455 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10456 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 10457 svctest.SetClusterIPs(api.ClusterIPNone)), 10458 expectHeadless: true, 10459 prove: prove(proveNumFamilies(2)), 10460 }, 10461 update: svcTestCase{ 10462 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10463 svctest.SetSelector(map[string]string{"k2": "v2"}), 10464 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 10465 svctest.SetIPFamilies("IPv4")), 10466 expectError: true, 10467 }, 10468 }, { 10469 name: "policy:require_families:dual", 10470 line: line(), 10471 create: svcTestCase{ 10472 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10473 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 10474 svctest.SetClusterIPs(api.ClusterIPNone)), 10475 expectHeadless: true, 10476 prove: prove(proveNumFamilies(2)), 10477 }, 10478 update: svcTestCase{ 10479 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10480 svctest.SetSelector(map[string]string{"k2": "v2"}), 10481 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack), 10482 svctest.SetIPFamilies("IPv4", "IPv6")), 10483 expectHeadless: true, 10484 prove: prove(proveNumFamilies(2)), 10485 }, 10486 }} 10487 10488 t.Run("headless", func(t *testing.T) { 10489 helpTestCreateUpdateDeleteWithFamilies(t, testCasesHeadless, []api.IPFamily{api.IPv4Protocol, api.IPv6Protocol}) 10490 }) 10491 } 10492 10493 func TestFeatureExternalName(t *testing.T) { 10494 testCases := []cudTestCase{{ 10495 name: "valid-valid", 10496 create: svcTestCase{ 10497 svc: svctest.MakeService("foo", svctest.SetTypeExternalName), 10498 }, 10499 update: svcTestCase{ 10500 svc: svctest.MakeService("foo", svctest.SetTypeExternalName, svctest.SetExternalName("updated.example.com")), 10501 }, 10502 }, { 10503 name: "valid-blank", 10504 create: svcTestCase{ 10505 svc: svctest.MakeService("foo", svctest.SetTypeExternalName), 10506 }, 10507 update: svcTestCase{ 10508 svc: svctest.MakeService("foo", svctest.SetTypeExternalName, svctest.SetExternalName("")), 10509 expectError: true, 10510 }, 10511 }} 10512 10513 helpTestCreateUpdateDelete(t, testCases) 10514 } 10515 10516 func TestFeatureSelector(t *testing.T) { 10517 testCases := []cudTestCase{{ 10518 name: "valid-valid", 10519 create: svcTestCase{ 10520 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP), 10521 expectClusterIPs: true, 10522 }, 10523 update: svcTestCase{ 10524 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10525 func(s *api.Service) { 10526 s.Spec.Selector = map[string]string{"updated": "value"} 10527 }), 10528 expectClusterIPs: true, 10529 }, 10530 }, { 10531 name: "valid-nil", 10532 create: svcTestCase{ 10533 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP), 10534 expectClusterIPs: true, 10535 }, 10536 update: svcTestCase{ 10537 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10538 func(s *api.Service) { 10539 s.Spec.Selector = nil 10540 }), 10541 expectClusterIPs: true, 10542 }, 10543 }, { 10544 name: "valid-empty", 10545 create: svcTestCase{ 10546 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP), 10547 expectClusterIPs: true, 10548 }, 10549 update: svcTestCase{ 10550 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10551 func(s *api.Service) { 10552 s.Spec.Selector = map[string]string{} 10553 }), 10554 expectClusterIPs: true, 10555 }, 10556 }, { 10557 name: "nil-valid", 10558 create: svcTestCase{ 10559 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10560 func(s *api.Service) { 10561 s.Spec.Selector = nil 10562 }), 10563 expectClusterIPs: true, 10564 }, 10565 update: svcTestCase{ 10566 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP), 10567 expectClusterIPs: true, 10568 }, 10569 }, { 10570 name: "empty-valid", 10571 create: svcTestCase{ 10572 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10573 func(s *api.Service) { 10574 s.Spec.Selector = map[string]string{} 10575 }), 10576 expectClusterIPs: true, 10577 }, 10578 update: svcTestCase{ 10579 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP), 10580 expectClusterIPs: true, 10581 }, 10582 }} 10583 10584 helpTestCreateUpdateDelete(t, testCases) 10585 } 10586 10587 func TestFeatureClusterIPs(t *testing.T) { 10588 testCases := []cudTestCase{{ 10589 name: "clusterIP:valid-headless", 10590 create: svcTestCase{ 10591 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP), 10592 expectClusterIPs: true, 10593 }, 10594 update: svcTestCase{ 10595 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10596 svctest.SetHeadless), 10597 expectError: true, 10598 }, 10599 }, { 10600 name: "clusterIP:headless-valid", 10601 create: svcTestCase{ 10602 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10603 svctest.SetHeadless), 10604 expectHeadless: true, 10605 }, 10606 update: svcTestCase{ 10607 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10608 svctest.SetClusterIP("10.0.0.93")), 10609 expectError: true, 10610 }, 10611 }, { 10612 name: "clusterIP:valid-valid", 10613 create: svcTestCase{ 10614 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10615 svctest.SetClusterIP("10.0.0.93")), 10616 expectClusterIPs: true, 10617 }, 10618 update: svcTestCase{ 10619 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10620 svctest.SetClusterIP("10.0.0.76")), 10621 expectError: true, 10622 }, 10623 }, { 10624 name: "clusterIPs:valid-valid", 10625 create: svcTestCase{ 10626 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10627 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 10628 svctest.SetClusterIPs("10.0.0.93", "2000::93")), 10629 expectClusterIPs: true, 10630 }, 10631 update: svcTestCase{ 10632 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10633 svctest.SetIPFamilyPolicy(api.IPFamilyPolicyPreferDualStack), 10634 svctest.SetClusterIPs("10.0.0.76", "2000::76")), 10635 expectError: true, 10636 }, 10637 }} 10638 10639 helpTestCreateUpdateDelete(t, testCases) 10640 } 10641 10642 func TestFeaturePorts(t *testing.T) { 10643 testCases := []cudTestCase{{ 10644 name: "add_port", 10645 create: svcTestCase{ 10646 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10647 svctest.SetPorts( 10648 svctest.MakeServicePort("p", 80, intstr.FromInt32(80), api.ProtocolTCP))), 10649 expectClusterIPs: true, 10650 }, 10651 update: svcTestCase{ 10652 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10653 svctest.SetPorts( 10654 svctest.MakeServicePort("p", 80, intstr.FromInt32(80), api.ProtocolTCP), 10655 svctest.MakeServicePort("q", 443, intstr.FromInt32(443), api.ProtocolTCP))), 10656 expectClusterIPs: true, 10657 }, 10658 }, { 10659 name: "add_port_ClusterIP-NodePort", 10660 create: svcTestCase{ 10661 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10662 svctest.SetPorts( 10663 svctest.MakeServicePort("p", 80, intstr.FromInt32(80), api.ProtocolTCP))), 10664 expectClusterIPs: true, 10665 }, 10666 update: svcTestCase{ 10667 svc: svctest.MakeService("foo", svctest.SetTypeNodePort, 10668 svctest.SetPorts( 10669 svctest.MakeServicePort("p", 80, intstr.FromInt32(80), api.ProtocolTCP), 10670 svctest.MakeServicePort("q", 443, intstr.FromInt32(443), api.ProtocolTCP))), 10671 expectClusterIPs: true, 10672 expectNodePorts: true, 10673 }, 10674 }, { 10675 name: "add_port_NodePort-ClusterIP", 10676 create: svcTestCase{ 10677 svc: svctest.MakeService("foo", svctest.SetTypeNodePort, 10678 svctest.SetPorts( 10679 svctest.MakeServicePort("p", 80, intstr.FromInt32(80), api.ProtocolTCP))), 10680 expectClusterIPs: true, 10681 expectNodePorts: true, 10682 }, 10683 update: svcTestCase{ 10684 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10685 svctest.SetPorts( 10686 svctest.MakeServicePort("p", 80, intstr.FromInt32(80), api.ProtocolTCP), 10687 svctest.MakeServicePort("q", 443, intstr.FromInt32(443), api.ProtocolTCP))), 10688 expectClusterIPs: true, 10689 }, 10690 }, { 10691 name: "remove_port", 10692 create: svcTestCase{ 10693 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10694 svctest.SetPorts( 10695 svctest.MakeServicePort("p", 80, intstr.FromInt32(80), api.ProtocolTCP), 10696 svctest.MakeServicePort("q", 443, intstr.FromInt32(443), api.ProtocolTCP))), 10697 expectClusterIPs: true, 10698 }, 10699 update: svcTestCase{ 10700 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10701 svctest.SetPorts( 10702 svctest.MakeServicePort("p", 80, intstr.FromInt32(80), api.ProtocolTCP))), 10703 expectClusterIPs: true, 10704 }, 10705 }, { 10706 name: "remove_port_ClusterIP-NodePort", 10707 create: svcTestCase{ 10708 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10709 svctest.SetPorts( 10710 svctest.MakeServicePort("p", 80, intstr.FromInt32(80), api.ProtocolTCP), 10711 svctest.MakeServicePort("q", 443, intstr.FromInt32(443), api.ProtocolTCP))), 10712 expectClusterIPs: true, 10713 }, 10714 update: svcTestCase{ 10715 svc: svctest.MakeService("foo", svctest.SetTypeNodePort, 10716 svctest.SetPorts( 10717 svctest.MakeServicePort("p", 80, intstr.FromInt32(80), api.ProtocolTCP))), 10718 expectClusterIPs: true, 10719 expectNodePorts: true, 10720 }, 10721 }, { 10722 name: "remove_port_NodePort-ClusterIP", 10723 create: svcTestCase{ 10724 svc: svctest.MakeService("foo", svctest.SetTypeNodePort, 10725 svctest.SetPorts( 10726 svctest.MakeServicePort("p", 80, intstr.FromInt32(80), api.ProtocolTCP), 10727 svctest.MakeServicePort("q", 443, intstr.FromInt32(443), api.ProtocolTCP))), 10728 expectClusterIPs: true, 10729 expectNodePorts: true, 10730 }, 10731 update: svcTestCase{ 10732 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10733 svctest.SetPorts( 10734 svctest.MakeServicePort("p", 80, intstr.FromInt32(80), api.ProtocolTCP))), 10735 expectClusterIPs: true, 10736 }, 10737 }, { 10738 name: "swap_ports", 10739 create: svcTestCase{ 10740 svc: svctest.MakeService("foo", svctest.SetTypeNodePort, 10741 svctest.SetPorts( 10742 svctest.MakeServicePort("p", 80, intstr.FromInt32(80), api.ProtocolTCP), 10743 svctest.MakeServicePort("q", 443, intstr.FromInt32(443), api.ProtocolTCP))), 10744 expectClusterIPs: true, 10745 expectNodePorts: true, 10746 }, 10747 update: svcTestCase{ 10748 svc: svctest.MakeService("foo", svctest.SetTypeNodePort, 10749 svctest.SetPorts( 10750 svctest.MakeServicePort("q", 443, intstr.FromInt32(443), api.ProtocolTCP), 10751 svctest.MakeServicePort("p", 80, intstr.FromInt32(80), api.ProtocolTCP))), 10752 expectClusterIPs: true, 10753 expectNodePorts: true, 10754 }, 10755 }, { 10756 name: "modify_ports", 10757 create: svcTestCase{ 10758 svc: svctest.MakeService("foo", svctest.SetTypeNodePort, 10759 svctest.SetPorts( 10760 svctest.MakeServicePort("p", 80, intstr.FromInt32(80), api.ProtocolTCP), 10761 svctest.MakeServicePort("q", 443, intstr.FromInt32(443), api.ProtocolTCP))), 10762 expectClusterIPs: true, 10763 expectNodePorts: true, 10764 }, 10765 update: svcTestCase{ 10766 svc: svctest.MakeService("foo", svctest.SetTypeNodePort, 10767 svctest.SetPorts( 10768 svctest.MakeServicePort("p", 8080, intstr.FromInt32(8080), api.ProtocolTCP), 10769 svctest.MakeServicePort("q", 8443, intstr.FromInt32(8443), api.ProtocolTCP))), 10770 expectClusterIPs: true, 10771 expectNodePorts: true, 10772 }, 10773 }, { 10774 name: "modify_protos", 10775 create: svcTestCase{ 10776 svc: svctest.MakeService("foo", svctest.SetTypeNodePort, 10777 svctest.SetPorts( 10778 svctest.MakeServicePort("p", 80, intstr.FromInt32(80), api.ProtocolTCP), 10779 svctest.MakeServicePort("q", 443, intstr.FromInt32(443), api.ProtocolTCP))), 10780 expectClusterIPs: true, 10781 expectNodePorts: true, 10782 }, 10783 update: svcTestCase{ 10784 svc: svctest.MakeService("foo", svctest.SetTypeNodePort, 10785 svctest.SetPorts( 10786 svctest.MakeServicePort("p", 80, intstr.FromInt32(80), api.ProtocolUDP), 10787 svctest.MakeServicePort("q", 443, intstr.FromInt32(443), api.ProtocolUDP))), 10788 expectClusterIPs: true, 10789 expectNodePorts: true, 10790 }, 10791 }, { 10792 name: "modify_ports_and_protos", 10793 create: svcTestCase{ 10794 svc: svctest.MakeService("foo", svctest.SetTypeNodePort, 10795 svctest.SetPorts( 10796 svctest.MakeServicePort("p", 80, intstr.FromInt32(80), api.ProtocolTCP), 10797 svctest.MakeServicePort("q", 443, intstr.FromInt32(443), api.ProtocolTCP))), 10798 expectClusterIPs: true, 10799 expectNodePorts: true, 10800 }, 10801 update: svcTestCase{ 10802 svc: svctest.MakeService("foo", svctest.SetTypeNodePort, 10803 svctest.SetPorts( 10804 svctest.MakeServicePort("r", 53, intstr.FromInt32(53), api.ProtocolTCP), 10805 svctest.MakeServicePort("s", 53, intstr.FromInt32(53), api.ProtocolUDP))), 10806 expectClusterIPs: true, 10807 expectNodePorts: true, 10808 }, 10809 }, { 10810 name: "add_alt_proto", 10811 create: svcTestCase{ 10812 svc: svctest.MakeService("foo", svctest.SetTypeNodePort, 10813 svctest.SetPorts( 10814 svctest.MakeServicePort("p", 53, intstr.FromInt32(53), api.ProtocolTCP))), 10815 expectClusterIPs: true, 10816 expectNodePorts: true, 10817 }, 10818 update: svcTestCase{ 10819 svc: svctest.MakeService("foo", svctest.SetTypeNodePort, 10820 svctest.SetPorts( 10821 svctest.MakeServicePort("p", 53, intstr.FromInt32(53), api.ProtocolTCP), 10822 svctest.MakeServicePort("q", 53, intstr.FromInt32(53), api.ProtocolUDP))), 10823 expectClusterIPs: true, 10824 expectNodePorts: true, 10825 }, 10826 }, { 10827 name: "wipe_all", 10828 create: svcTestCase{ 10829 svc: svctest.MakeService("foo", svctest.SetTypeNodePort, 10830 svctest.SetPorts( 10831 svctest.MakeServicePort("p", 80, intstr.FromInt32(80), api.ProtocolTCP), 10832 svctest.MakeServicePort("q", 443, intstr.FromInt32(443), api.ProtocolTCP))), 10833 expectClusterIPs: true, 10834 expectNodePorts: true, 10835 }, 10836 update: svcTestCase{ 10837 svc: svctest.MakeService("foo", svctest.SetTypeNodePort, 10838 svctest.SetPorts()), 10839 expectError: true, 10840 expectNodePorts: true, 10841 }, 10842 }} 10843 10844 helpTestCreateUpdateDelete(t, testCases) 10845 } 10846 10847 func TestFeatureSessionAffinity(t *testing.T) { 10848 testCases := []cudTestCase{{ 10849 name: "None-ClientIPNoConfig", 10850 create: svcTestCase{ 10851 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10852 svctest.SetSessionAffinity(api.ServiceAffinityNone)), 10853 expectClusterIPs: true, 10854 }, 10855 update: svcTestCase{ 10856 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10857 func(s *api.Service) { 10858 // Set it without setting the config 10859 s.Spec.SessionAffinity = api.ServiceAffinityClientIP 10860 }), 10861 expectError: true, 10862 }, 10863 }, { 10864 name: "None-ClientIP", 10865 create: svcTestCase{ 10866 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10867 svctest.SetSessionAffinity(api.ServiceAffinityNone)), 10868 expectClusterIPs: true, 10869 }, 10870 update: svcTestCase{ 10871 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10872 svctest.SetSessionAffinity(api.ServiceAffinityClientIP)), 10873 expectClusterIPs: true, 10874 }, 10875 }, { 10876 name: "ClientIP-NoneWithConfig", 10877 create: svcTestCase{ 10878 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10879 svctest.SetSessionAffinity(api.ServiceAffinityClientIP)), 10880 expectClusterIPs: true, 10881 }, 10882 update: svcTestCase{ 10883 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10884 svctest.SetSessionAffinity(api.ServiceAffinityClientIP), 10885 func(s *api.Service) { 10886 // Set it without wiping the config 10887 s.Spec.SessionAffinity = api.ServiceAffinityNone 10888 }), 10889 expectError: true, 10890 }, 10891 }, { 10892 name: "ClientIP-None", 10893 create: svcTestCase{ 10894 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10895 svctest.SetSessionAffinity(api.ServiceAffinityClientIP)), 10896 expectClusterIPs: true, 10897 }, 10898 update: svcTestCase{ 10899 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP, 10900 svctest.SetSessionAffinity(api.ServiceAffinityNone), 10901 func(s *api.Service) { 10902 s.Spec.SessionAffinityConfig = nil 10903 }), 10904 expectClusterIPs: true, 10905 }, 10906 }} 10907 10908 helpTestCreateUpdateDelete(t, testCases) 10909 } 10910 10911 func TestFeatureType(t *testing.T) { 10912 testCases := []cudTestCase{{ 10913 name: "ExternalName-ClusterIP", 10914 create: svcTestCase{ 10915 svc: svctest.MakeService("foo", svctest.SetTypeExternalName), 10916 }, 10917 update: svcTestCase{ 10918 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP), 10919 expectClusterIPs: true, 10920 }, 10921 }, { 10922 name: "ClusterIP-ExternalName", 10923 create: svcTestCase{ 10924 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP), 10925 expectClusterIPs: true, 10926 }, 10927 update: svcTestCase{ 10928 svc: svctest.MakeService("foo", svctest.SetTypeExternalName), 10929 }, 10930 }, { 10931 name: "ExternalName-NodePort", 10932 create: svcTestCase{ 10933 svc: svctest.MakeService("foo", svctest.SetTypeExternalName), 10934 }, 10935 update: svcTestCase{ 10936 svc: svctest.MakeService("foo", svctest.SetTypeNodePort), 10937 expectClusterIPs: true, 10938 expectNodePorts: true, 10939 }, 10940 }, { 10941 name: "NodePort-ExternalName", 10942 create: svcTestCase{ 10943 svc: svctest.MakeService("foo", svctest.SetTypeNodePort), 10944 expectClusterIPs: true, 10945 expectNodePorts: true, 10946 }, 10947 update: svcTestCase{ 10948 svc: svctest.MakeService("foo", svctest.SetTypeExternalName), 10949 }, 10950 }, { 10951 name: "ExternalName-LoadBalancer", 10952 create: svcTestCase{ 10953 svc: svctest.MakeService("foo", svctest.SetTypeExternalName), 10954 }, 10955 update: svcTestCase{ 10956 svc: svctest.MakeService("foo", svctest.SetTypeLoadBalancer), 10957 expectClusterIPs: true, 10958 expectNodePorts: true, 10959 }, 10960 }, { 10961 name: "LoadBalancer-ExternalName", 10962 create: svcTestCase{ 10963 svc: svctest.MakeService("foo", svctest.SetTypeLoadBalancer), 10964 expectClusterIPs: true, 10965 expectNodePorts: true, 10966 }, 10967 update: svcTestCase{ 10968 svc: svctest.MakeService("foo", svctest.SetTypeExternalName), 10969 }, 10970 }, { 10971 name: "ClusterIP-NodePort", 10972 create: svcTestCase{ 10973 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP), 10974 expectClusterIPs: true, 10975 }, 10976 update: svcTestCase{ 10977 svc: svctest.MakeService("foo", svctest.SetTypeNodePort), 10978 expectClusterIPs: true, 10979 expectNodePorts: true, 10980 }, 10981 }, { 10982 name: "NodePort-ClusterIP", 10983 create: svcTestCase{ 10984 svc: svctest.MakeService("foo", svctest.SetTypeNodePort), 10985 expectClusterIPs: true, 10986 expectNodePorts: true, 10987 }, 10988 update: svcTestCase{ 10989 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP), 10990 expectClusterIPs: true, 10991 }, 10992 }, { 10993 name: "ClusterIP-LoadBalancer", 10994 create: svcTestCase{ 10995 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP), 10996 expectClusterIPs: true, 10997 }, 10998 update: svcTestCase{ 10999 svc: svctest.MakeService("foo", svctest.SetTypeLoadBalancer), 11000 expectClusterIPs: true, 11001 expectNodePorts: true, 11002 }, 11003 }, { 11004 name: "LoadBalancer-ClusterIP", 11005 create: svcTestCase{ 11006 svc: svctest.MakeService("foo", svctest.SetTypeLoadBalancer), 11007 expectClusterIPs: true, 11008 expectNodePorts: true, 11009 }, 11010 update: svcTestCase{ 11011 svc: svctest.MakeService("foo", svctest.SetTypeClusterIP), 11012 expectClusterIPs: true, 11013 }, 11014 }, { 11015 name: "NodePort-LoadBalancer", 11016 create: svcTestCase{ 11017 svc: svctest.MakeService("foo", svctest.SetTypeNodePort), 11018 expectClusterIPs: true, 11019 expectNodePorts: true, 11020 }, 11021 update: svcTestCase{ 11022 svc: svctest.MakeService("foo", svctest.SetTypeLoadBalancer), 11023 expectClusterIPs: true, 11024 expectNodePorts: true, 11025 }, 11026 }, { 11027 name: "LoadBalancer-NodePort", 11028 create: svcTestCase{ 11029 svc: svctest.MakeService("foo", svctest.SetTypeLoadBalancer), 11030 expectClusterIPs: true, 11031 expectNodePorts: true, 11032 }, 11033 update: svcTestCase{ 11034 svc: svctest.MakeService("foo", svctest.SetTypeNodePort), 11035 expectClusterIPs: true, 11036 expectNodePorts: true, 11037 }, 11038 }, { 11039 name: "Headless-ExternalName", 11040 create: svcTestCase{ 11041 svc: svctest.MakeService("foo", svctest.SetHeadless), 11042 expectHeadless: true, 11043 }, 11044 update: svcTestCase{ 11045 svc: svctest.MakeService("foo", svctest.SetTypeExternalName), 11046 }, 11047 }, { 11048 name: "ExternalName-Headless", 11049 create: svcTestCase{ 11050 svc: svctest.MakeService("foo", svctest.SetTypeExternalName), 11051 }, 11052 update: svcTestCase{ 11053 svc: svctest.MakeService("foo", svctest.SetHeadless), 11054 expectHeadless: true, 11055 }, 11056 }, { 11057 name: "Headless-NodePort", 11058 create: svcTestCase{ 11059 svc: svctest.MakeService("foo", svctest.SetHeadless), 11060 expectHeadless: true, 11061 }, 11062 update: svcTestCase{ 11063 svc: svctest.MakeService("foo", svctest.SetTypeNodePort), 11064 expectError: true, 11065 }, 11066 }, { 11067 name: "NodePort-Headless", 11068 create: svcTestCase{ 11069 svc: svctest.MakeService("foo", svctest.SetTypeNodePort), 11070 expectClusterIPs: true, 11071 expectNodePorts: true, 11072 }, 11073 update: svcTestCase{ 11074 svc: svctest.MakeService("foo", svctest.SetHeadless), 11075 expectError: true, 11076 }, 11077 }, { 11078 name: "Headless-LoadBalancer", 11079 create: svcTestCase{ 11080 svc: svctest.MakeService("foo", svctest.SetHeadless), 11081 expectHeadless: true, 11082 }, 11083 update: svcTestCase{ 11084 svc: svctest.MakeService("foo", svctest.SetTypeLoadBalancer), 11085 expectError: true, 11086 }, 11087 }, { 11088 name: "LoadBalancer-Headless", 11089 create: svcTestCase{ 11090 svc: svctest.MakeService("foo", svctest.SetTypeLoadBalancer), 11091 expectClusterIPs: true, 11092 expectNodePorts: true, 11093 }, 11094 update: svcTestCase{ 11095 svc: svctest.MakeService("foo", svctest.SetHeadless), 11096 expectError: true, 11097 }, 11098 }} 11099 11100 helpTestCreateUpdateDelete(t, testCases) 11101 } 11102 11103 func TestFeatureExternalTrafficPolicy(t *testing.T) { 11104 testCases := []cudTestCase{{ 11105 name: "ExternalName_policy:none_hcnp:specified", 11106 create: svcTestCase{ 11107 svc: svctest.MakeService("foo", 11108 svctest.SetTypeExternalName, 11109 svctest.SetExternalTrafficPolicy(""), 11110 svctest.SetHealthCheckNodePort(30000)), 11111 expectError: true, 11112 }, 11113 }, { 11114 name: "ExternalName_policy:Cluster_hcnp:none", 11115 create: svcTestCase{ 11116 svc: svctest.MakeService("foo", 11117 svctest.SetTypeExternalName, 11118 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyCluster)), 11119 expectError: true, 11120 }, 11121 }, { 11122 name: "ExternalName_policy:Cluster_hcnp:specified", 11123 create: svcTestCase{ 11124 svc: svctest.MakeService("foo", 11125 svctest.SetTypeExternalName, 11126 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyCluster), 11127 svctest.SetHealthCheckNodePort(30000)), 11128 expectError: true, 11129 }, 11130 }, { 11131 name: "ExternalName_policy:Local_hcnp:none", 11132 create: svcTestCase{ 11133 svc: svctest.MakeService("foo", 11134 svctest.SetTypeExternalName, 11135 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal)), 11136 expectError: true, 11137 }, 11138 }, { 11139 name: "ExternalName_policy:Local_hcnp:specified", 11140 create: svcTestCase{ 11141 svc: svctest.MakeService("foo", 11142 svctest.SetTypeExternalName, 11143 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal), 11144 svctest.SetHealthCheckNodePort(30000)), 11145 expectError: true, 11146 }, 11147 }, { 11148 name: "ClusterIP_policy:none_hcnp:none_policy:Cluster_hcnp:none", 11149 create: svcTestCase{ 11150 svc: svctest.MakeService("foo", 11151 svctest.SetTypeClusterIP, 11152 svctest.SetExternalTrafficPolicy("")), 11153 expectClusterIPs: true, 11154 }, 11155 update: svcTestCase{ 11156 svc: svctest.MakeService("foo", 11157 svctest.SetTypeClusterIP, 11158 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyCluster)), 11159 expectError: true, 11160 }, 11161 }, { 11162 name: "ClusterIP_policy:none_hcnp:specified", 11163 create: svcTestCase{ 11164 svc: svctest.MakeService("foo", 11165 svctest.SetTypeClusterIP, 11166 svctest.SetExternalTrafficPolicy(""), 11167 svctest.SetHealthCheckNodePort(30000)), 11168 expectError: true, 11169 }, 11170 }, { 11171 name: "ClusterIP_policy:Cluster_hcnp:none", 11172 create: svcTestCase{ 11173 svc: svctest.MakeService("foo", 11174 svctest.SetTypeClusterIP, 11175 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyCluster)), 11176 expectError: true, 11177 }, 11178 }, { 11179 name: "ClusterIP_policy:Cluster_hcnp:specified", 11180 create: svcTestCase{ 11181 svc: svctest.MakeService("foo", 11182 svctest.SetTypeClusterIP, 11183 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyCluster), 11184 svctest.SetHealthCheckNodePort(30000)), 11185 expectError: true, 11186 }, 11187 }, { 11188 name: "ClusterIP_policy:Local_hcnp:none", 11189 create: svcTestCase{ 11190 svc: svctest.MakeService("foo", 11191 svctest.SetTypeClusterIP, 11192 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal)), 11193 expectError: true, 11194 }, 11195 }, { 11196 name: "ClusterIP_policy:Local_hcnp:specified", 11197 create: svcTestCase{ 11198 svc: svctest.MakeService("foo", 11199 svctest.SetTypeClusterIP, 11200 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal), 11201 svctest.SetHealthCheckNodePort(30000)), 11202 expectError: true, 11203 }, 11204 }, { 11205 name: "NodePort_policy:none_hcnp:none", 11206 create: svcTestCase{ 11207 svc: svctest.MakeService("foo", 11208 svctest.SetTypeNodePort, 11209 svctest.SetExternalTrafficPolicy("")), 11210 expectError: true, 11211 }, 11212 }, { 11213 name: "NodePort_policy:none_hcnp:specified", 11214 create: svcTestCase{ 11215 svc: svctest.MakeService("foo", 11216 svctest.SetTypeNodePort, 11217 svctest.SetExternalTrafficPolicy(""), 11218 svctest.SetHealthCheckNodePort(30000)), 11219 expectError: true, 11220 }, 11221 }, { 11222 name: "NodePort_policy:Cluster_hcnp:none_policy:Local_hcnp:none", 11223 create: svcTestCase{ 11224 svc: svctest.MakeService("foo", 11225 svctest.SetTypeNodePort, 11226 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyCluster)), 11227 expectClusterIPs: true, 11228 expectNodePorts: true, 11229 expectHealthCheckNodePort: false, 11230 }, 11231 update: svcTestCase{ 11232 svc: svctest.MakeService("foo", 11233 svctest.SetTypeNodePort, 11234 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal)), 11235 expectClusterIPs: true, 11236 expectNodePorts: true, 11237 expectHealthCheckNodePort: false, 11238 }, 11239 }, { 11240 name: "NodePort_policy:Cluster_hcnp:specified", 11241 create: svcTestCase{ 11242 svc: svctest.MakeService("foo", 11243 svctest.SetTypeNodePort, 11244 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyCluster), 11245 svctest.SetHealthCheckNodePort(30000)), 11246 expectError: true, 11247 }, 11248 }, { 11249 name: "NodePort_policy:Local_hcnp:none_policy:Cluster_hcnp:none", 11250 create: svcTestCase{ 11251 svc: svctest.MakeService("foo", 11252 svctest.SetTypeNodePort, 11253 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal)), 11254 expectClusterIPs: true, 11255 expectNodePorts: true, 11256 expectHealthCheckNodePort: false, 11257 }, 11258 update: svcTestCase{ 11259 svc: svctest.MakeService("foo", 11260 svctest.SetTypeNodePort, 11261 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyCluster)), 11262 expectClusterIPs: true, 11263 expectNodePorts: true, 11264 expectHealthCheckNodePort: false, 11265 }, 11266 }, { 11267 name: "NodePort_policy:Local_hcnp:specified", 11268 create: svcTestCase{ 11269 svc: svctest.MakeService("foo", 11270 svctest.SetTypeNodePort, 11271 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal), 11272 svctest.SetHealthCheckNodePort(30000)), 11273 expectError: true, 11274 }, 11275 }, { 11276 name: "LoadBalancer_policy:none_hcnp:none", 11277 create: svcTestCase{ 11278 svc: svctest.MakeService("foo", 11279 svctest.SetTypeLoadBalancer, 11280 svctest.SetExternalTrafficPolicy("")), 11281 expectError: true, 11282 }, 11283 }, { 11284 name: "LoadBalancer_policy:none_hcnp:specified", 11285 create: svcTestCase{ 11286 svc: svctest.MakeService("foo", 11287 svctest.SetTypeLoadBalancer, 11288 svctest.SetExternalTrafficPolicy(""), 11289 svctest.SetHealthCheckNodePort(30000)), 11290 expectError: true, 11291 }, 11292 }, { 11293 name: "LoadBalancer_policy:Cluster_hcnp:none_policy:Local_hcnp:none", 11294 create: svcTestCase{ 11295 svc: svctest.MakeService("foo", 11296 svctest.SetTypeLoadBalancer, 11297 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyCluster)), 11298 expectClusterIPs: true, 11299 expectNodePorts: true, 11300 expectHealthCheckNodePort: false, 11301 }, 11302 update: svcTestCase{ 11303 svc: svctest.MakeService("foo", 11304 svctest.SetTypeLoadBalancer, 11305 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal)), 11306 expectClusterIPs: true, 11307 expectNodePorts: true, 11308 expectHealthCheckNodePort: true, 11309 }, 11310 }, { 11311 name: "LoadBalancer_policy:Cluster_hcnp:none_policy:Local_hcnp:specified", 11312 create: svcTestCase{ 11313 svc: svctest.MakeService("foo", 11314 svctest.SetTypeLoadBalancer, 11315 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyCluster)), 11316 expectClusterIPs: true, 11317 expectNodePorts: true, 11318 expectHealthCheckNodePort: false, 11319 }, 11320 update: svcTestCase{ 11321 svc: svctest.MakeService("foo", 11322 svctest.SetTypeLoadBalancer, 11323 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal), 11324 svctest.SetHealthCheckNodePort(30000)), 11325 expectClusterIPs: true, 11326 expectNodePorts: true, 11327 expectHealthCheckNodePort: true, 11328 }, 11329 }, { 11330 name: "LoadBalancer_policy:Cluster_hcnp:specified", 11331 create: svcTestCase{ 11332 svc: svctest.MakeService("foo", 11333 svctest.SetTypeLoadBalancer, 11334 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyCluster), 11335 svctest.SetHealthCheckNodePort(30000)), 11336 expectError: true, 11337 }, 11338 }, { 11339 name: "LoadBalancer_policy:Local_hcnp:none_policy:Cluster_hcnp:none", 11340 create: svcTestCase{ 11341 svc: svctest.MakeService("foo", 11342 svctest.SetTypeLoadBalancer, 11343 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal)), 11344 expectClusterIPs: true, 11345 expectNodePorts: true, 11346 expectHealthCheckNodePort: true, 11347 }, 11348 update: svcTestCase{ 11349 svc: svctest.MakeService("foo", 11350 svctest.SetTypeLoadBalancer, 11351 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyCluster)), 11352 expectClusterIPs: true, 11353 expectNodePorts: true, 11354 expectHealthCheckNodePort: false, 11355 }, 11356 }, { 11357 name: "LoadBalancer_policy:Local_hcnp:specified_policy:Cluster_hcnp:none", 11358 create: svcTestCase{ 11359 svc: svctest.MakeService("foo", 11360 svctest.SetTypeLoadBalancer, 11361 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal), 11362 svctest.SetHealthCheckNodePort(30000)), 11363 expectClusterIPs: true, 11364 expectNodePorts: true, 11365 expectHealthCheckNodePort: true, 11366 }, 11367 update: svcTestCase{ 11368 svc: svctest.MakeService("foo", 11369 svctest.SetTypeLoadBalancer, 11370 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyCluster)), 11371 expectClusterIPs: true, 11372 expectNodePorts: true, 11373 expectHealthCheckNodePort: false, 11374 }, 11375 }, { 11376 name: "LoadBalancer_policy:Local_hcnp:specified_policy:Cluster_hcnp:different", 11377 create: svcTestCase{ 11378 svc: svctest.MakeService("foo", 11379 svctest.SetTypeLoadBalancer, 11380 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal), 11381 svctest.SetHealthCheckNodePort(30000)), 11382 expectClusterIPs: true, 11383 expectNodePorts: true, 11384 expectHealthCheckNodePort: true, 11385 }, 11386 update: svcTestCase{ 11387 svc: svctest.MakeService("foo", 11388 svctest.SetTypeLoadBalancer, 11389 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal), 11390 svctest.SetHealthCheckNodePort(30001)), 11391 expectError: true, 11392 }, 11393 }, { 11394 name: "LoadBalancer_policy:Local_hcnp:none_policy:Inalid", 11395 create: svcTestCase{ 11396 svc: svctest.MakeService("foo", 11397 svctest.SetTypeLoadBalancer, 11398 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal)), 11399 expectClusterIPs: true, 11400 expectNodePorts: true, 11401 expectHealthCheckNodePort: true, 11402 }, 11403 update: svcTestCase{ 11404 svc: svctest.MakeService("foo", 11405 svctest.SetTypeLoadBalancer, 11406 svctest.SetExternalTrafficPolicy("Invalid")), 11407 expectError: true, 11408 }, 11409 }, { 11410 name: "LoadBalancer_policy:Local_hcnp:negative", 11411 create: svcTestCase{ 11412 svc: svctest.MakeService("foo", 11413 svctest.SetTypeLoadBalancer, 11414 svctest.SetExternalTrafficPolicy(api.ServiceExternalTrafficPolicyLocal), 11415 svctest.SetHealthCheckNodePort(-1)), 11416 expectError: true, 11417 }, 11418 }} 11419 11420 helpTestCreateUpdateDelete(t, testCases) 11421 } 11422 11423 func TestFeatureInternalTrafficPolicy(t *testing.T) { 11424 prove := func(proofs ...svcTestProof) []svcTestProof { 11425 return proofs 11426 } 11427 proveITP := func(want api.ServiceInternalTrafficPolicy) svcTestProof { 11428 return func(t *testing.T, storage *wrapperRESTForTests, before, after *api.Service) { 11429 t.Helper() 11430 if got := after.Spec.InternalTrafficPolicy; got == nil { 11431 if want != "" { 11432 t.Errorf("internalTrafficPolicy was nil") 11433 } 11434 } else if *got != want { 11435 if want == "" { 11436 want = "nil" 11437 } 11438 t.Errorf("wrong internalTrafficPoilcy: expected %s, got %s", want, *got) 11439 } 11440 } 11441 } 11442 11443 testCases := []cudTestCase{{ 11444 name: "ExternalName_policy:none-ExternalName_policy:none", 11445 create: svcTestCase{ 11446 svc: svctest.MakeService("foo", 11447 svctest.SetTypeExternalName), 11448 prove: prove(proveITP("")), 11449 }, 11450 update: svcTestCase{ 11451 svc: svctest.MakeService("foo", 11452 svctest.SetTypeExternalName), 11453 prove: prove(proveITP("")), 11454 }, 11455 }, { 11456 name: "ClusterIP_policy:none-ClusterIP_policy:Local", 11457 create: svcTestCase{ 11458 svc: svctest.MakeService("foo", 11459 svctest.SetTypeClusterIP), 11460 expectClusterIPs: true, 11461 prove: prove(proveITP(api.ServiceInternalTrafficPolicyCluster)), 11462 }, 11463 update: svcTestCase{ 11464 svc: svctest.MakeService("foo", 11465 svctest.SetTypeClusterIP, 11466 svctest.SetInternalTrafficPolicy(api.ServiceInternalTrafficPolicyLocal)), 11467 expectClusterIPs: true, 11468 prove: prove(proveITP(api.ServiceInternalTrafficPolicyLocal)), 11469 }, 11470 }, { 11471 name: "ClusterIP_policy:Cluster-ClusterIP_policy:Local", 11472 create: svcTestCase{ 11473 svc: svctest.MakeService("foo", 11474 svctest.SetTypeClusterIP, 11475 svctest.SetInternalTrafficPolicy(api.ServiceInternalTrafficPolicyCluster)), 11476 expectClusterIPs: true, 11477 prove: prove(proveITP(api.ServiceInternalTrafficPolicyCluster)), 11478 }, 11479 update: svcTestCase{ 11480 svc: svctest.MakeService("foo", 11481 svctest.SetTypeClusterIP, 11482 svctest.SetInternalTrafficPolicy(api.ServiceInternalTrafficPolicyLocal)), 11483 expectClusterIPs: true, 11484 prove: prove(proveITP(api.ServiceInternalTrafficPolicyLocal)), 11485 }, 11486 }, { 11487 name: "NodePort_policy:none-NodePort_policy:Local", 11488 create: svcTestCase{ 11489 svc: svctest.MakeService("foo", 11490 svctest.SetTypeNodePort), 11491 expectClusterIPs: true, 11492 expectNodePorts: true, 11493 prove: prove(proveITP(api.ServiceInternalTrafficPolicyCluster)), 11494 }, 11495 update: svcTestCase{ 11496 svc: svctest.MakeService("foo", 11497 svctest.SetTypeNodePort, 11498 svctest.SetInternalTrafficPolicy(api.ServiceInternalTrafficPolicyLocal)), 11499 expectClusterIPs: true, 11500 expectNodePorts: true, 11501 prove: prove(proveITP(api.ServiceInternalTrafficPolicyLocal)), 11502 }, 11503 }, { 11504 name: "NodePort_policy:Cluster-NodePort_policy:Local", 11505 create: svcTestCase{ 11506 svc: svctest.MakeService("foo", 11507 svctest.SetTypeNodePort, 11508 svctest.SetInternalTrafficPolicy(api.ServiceInternalTrafficPolicyCluster)), 11509 expectClusterIPs: true, 11510 expectNodePorts: true, 11511 prove: prove(proveITP(api.ServiceInternalTrafficPolicyCluster)), 11512 }, 11513 update: svcTestCase{ 11514 svc: svctest.MakeService("foo", 11515 svctest.SetTypeNodePort, 11516 svctest.SetInternalTrafficPolicy(api.ServiceInternalTrafficPolicyLocal)), 11517 expectClusterIPs: true, 11518 expectNodePorts: true, 11519 prove: prove(proveITP(api.ServiceInternalTrafficPolicyLocal)), 11520 }, 11521 }, { 11522 name: "LoadBalancer_policy:none-LoadBalancer_policy:Local", 11523 create: svcTestCase{ 11524 svc: svctest.MakeService("foo", 11525 svctest.SetTypeLoadBalancer), 11526 expectClusterIPs: true, 11527 expectNodePorts: true, 11528 prove: prove(proveITP(api.ServiceInternalTrafficPolicyCluster)), 11529 }, 11530 update: svcTestCase{ 11531 svc: svctest.MakeService("foo", 11532 svctest.SetTypeLoadBalancer, 11533 svctest.SetInternalTrafficPolicy(api.ServiceInternalTrafficPolicyLocal)), 11534 expectClusterIPs: true, 11535 expectNodePorts: true, 11536 prove: prove(proveITP(api.ServiceInternalTrafficPolicyLocal)), 11537 }, 11538 }, { 11539 name: "LoadBalancer_policy:Cluster-LoadBalancer_policy:Local", 11540 create: svcTestCase{ 11541 svc: svctest.MakeService("foo", 11542 svctest.SetTypeLoadBalancer, 11543 svctest.SetInternalTrafficPolicy(api.ServiceInternalTrafficPolicyCluster)), 11544 expectClusterIPs: true, 11545 expectNodePorts: true, 11546 prove: prove(proveITP(api.ServiceInternalTrafficPolicyCluster)), 11547 }, 11548 update: svcTestCase{ 11549 svc: svctest.MakeService("foo", 11550 svctest.SetTypeLoadBalancer, 11551 svctest.SetInternalTrafficPolicy(api.ServiceInternalTrafficPolicyLocal)), 11552 expectClusterIPs: true, 11553 expectNodePorts: true, 11554 prove: prove(proveITP(api.ServiceInternalTrafficPolicyLocal)), 11555 }, 11556 }, { 11557 name: "Headless_policy:none-Headless_policy:Local", 11558 create: svcTestCase{ 11559 svc: svctest.MakeService("foo", 11560 svctest.SetHeadless), 11561 expectHeadless: true, 11562 prove: prove(proveITP(api.ServiceInternalTrafficPolicyCluster)), 11563 }, 11564 update: svcTestCase{ 11565 svc: svctest.MakeService("foo", 11566 svctest.SetHeadless, 11567 svctest.SetInternalTrafficPolicy(api.ServiceInternalTrafficPolicyLocal)), 11568 expectHeadless: true, 11569 prove: prove(proveITP(api.ServiceInternalTrafficPolicyLocal)), 11570 }, 11571 }, { 11572 name: "Headless_policy:Cluster-Headless_policy:Local", 11573 create: svcTestCase{ 11574 svc: svctest.MakeService("foo", 11575 svctest.SetHeadless, 11576 svctest.SetInternalTrafficPolicy(api.ServiceInternalTrafficPolicyCluster)), 11577 expectHeadless: true, 11578 prove: prove(proveITP(api.ServiceInternalTrafficPolicyCluster)), 11579 }, 11580 update: svcTestCase{ 11581 svc: svctest.MakeService("foo", 11582 svctest.SetHeadless, 11583 svctest.SetInternalTrafficPolicy(api.ServiceInternalTrafficPolicyLocal)), 11584 expectHeadless: true, 11585 prove: prove(proveITP(api.ServiceInternalTrafficPolicyLocal)), 11586 }, 11587 }} 11588 11589 helpTestCreateUpdateDelete(t, testCases) 11590 } 11591 11592 // TODO(thockin): We need to look at feature-tests for: 11593 // externalIPs, lbip, lbsourceranges, externalname, PublishNotReadyAddresses, AllocateLoadBalancerNodePorts, LoadBalancerClass, status 11594 11595 // this is local because it's not fully fleshed out enough for general use. 11596 func makePod(name string, ips ...string) api.Pod { 11597 p := api.Pod{ 11598 ObjectMeta: metav1.ObjectMeta{ 11599 Name: name, 11600 Namespace: metav1.NamespaceDefault, 11601 }, 11602 Spec: api.PodSpec{ 11603 RestartPolicy: api.RestartPolicyAlways, 11604 DNSPolicy: api.DNSDefault, 11605 Containers: []api.Container{{Name: "ctr", Image: "img", ImagePullPolicy: api.PullIfNotPresent, TerminationMessagePolicy: api.TerminationMessageReadFile}}, 11606 }, 11607 Status: api.PodStatus{ 11608 PodIPs: []api.PodIP{}, 11609 }, 11610 } 11611 11612 for _, ip := range ips { 11613 p.Status.PodIPs = append(p.Status.PodIPs, api.PodIP{IP: ip}) 11614 } 11615 11616 return p 11617 } 11618 11619 func TestServiceRegistryResourceLocation(t *testing.T) { 11620 pods := []api.Pod{ 11621 makePod("unnamed", "1.2.3.4", "1.2.3.5"), 11622 makePod("named", "1.2.3.6", "1.2.3.7"), 11623 makePod("no-endpoints", "9.9.9.9"), // to prove this does not get chosen 11624 } 11625 11626 endpoints := []*api.Endpoints{ 11627 epstest.MakeEndpoints("unnamed", 11628 []api.EndpointAddress{ 11629 epstest.MakeEndpointAddress("1.2.3.4", "unnamed"), 11630 }, 11631 []api.EndpointPort{ 11632 epstest.MakeEndpointPort("", 80), 11633 }), 11634 epstest.MakeEndpoints("unnamed2", 11635 []api.EndpointAddress{ 11636 epstest.MakeEndpointAddress("1.2.3.5", "unnamed"), 11637 }, 11638 []api.EndpointPort{ 11639 epstest.MakeEndpointPort("", 80), 11640 }), 11641 epstest.MakeEndpoints("named", 11642 []api.EndpointAddress{ 11643 epstest.MakeEndpointAddress("1.2.3.6", "named"), 11644 }, 11645 []api.EndpointPort{ 11646 epstest.MakeEndpointPort("p", 80), 11647 epstest.MakeEndpointPort("q", 81), 11648 }), 11649 epstest.MakeEndpoints("no-endpoints", nil, nil), // to prove this does not get chosen 11650 } 11651 11652 storage, _, server := newStorageWithPods(t, []api.IPFamily{api.IPv4Protocol}, pods, endpoints) 11653 defer server.Terminate(t) 11654 defer storage.Store.DestroyFunc() 11655 11656 ctx := genericapirequest.NewDefaultContext() 11657 for _, name := range []string{"unnamed", "unnamed2", "no-endpoints"} { 11658 _, err := storage.Create(ctx, 11659 svctest.MakeService(name, 11660 svctest.SetPorts( 11661 svctest.MakeServicePort("", 93, intstr.FromInt32(80), api.ProtocolTCP))), 11662 rest.ValidateAllObjectFunc, &metav1.CreateOptions{}) 11663 if err != nil { 11664 t.Fatalf("unexpected error creating service %q: %v", name, err) 11665 } 11666 11667 } 11668 _, err := storage.Create(ctx, 11669 svctest.MakeService("named", 11670 svctest.SetPorts( 11671 svctest.MakeServicePort("p", 93, intstr.FromInt32(80), api.ProtocolTCP), 11672 svctest.MakeServicePort("q", 76, intstr.FromInt32(81), api.ProtocolTCP))), 11673 rest.ValidateAllObjectFunc, &metav1.CreateOptions{}) 11674 if err != nil { 11675 t.Fatalf("unexpected error creating service %q: %v", "named", err) 11676 } 11677 redirector := rest.Redirector(storage) 11678 11679 cases := []struct { 11680 query string 11681 err bool 11682 expect string 11683 }{{ 11684 query: "unnamed", 11685 expect: "//1.2.3.4:80", 11686 }, { 11687 query: "unnamed:", 11688 expect: "//1.2.3.4:80", 11689 }, { 11690 query: "unnamed:93", 11691 expect: "//1.2.3.4:80", 11692 }, { 11693 query: "http:unnamed:", 11694 expect: "http://1.2.3.4:80", 11695 }, { 11696 query: "http:unnamed:93", 11697 expect: "http://1.2.3.4:80", 11698 }, { 11699 query: "unnamed:80", 11700 err: true, 11701 }, { 11702 query: "unnamed2", 11703 expect: "//1.2.3.5:80", 11704 }, { 11705 query: "named:p", 11706 expect: "//1.2.3.6:80", 11707 }, { 11708 query: "named:q", 11709 expect: "//1.2.3.6:81", 11710 }, { 11711 query: "named:93", 11712 expect: "//1.2.3.6:80", 11713 }, { 11714 query: "named:76", 11715 expect: "//1.2.3.6:81", 11716 }, { 11717 query: "http:named:p", 11718 expect: "http://1.2.3.6:80", 11719 }, { 11720 query: "http:named:q", 11721 expect: "http://1.2.3.6:81", 11722 }, { 11723 query: "named:bad", 11724 err: true, 11725 }, { 11726 query: "no-endpoints", 11727 err: true, 11728 }, { 11729 query: "non-existent", 11730 err: true, 11731 }} 11732 for _, tc := range cases { 11733 t.Run(tc.query, func(t *testing.T) { 11734 location, _, err := redirector.ResourceLocation(ctx, tc.query) 11735 if tc.err == false && err != nil { 11736 t.Fatalf("unexpected error: %v", err) 11737 } 11738 if tc.err && err == nil { 11739 t.Fatalf("unexpected success") 11740 } 11741 if !tc.err { 11742 if location == nil { 11743 t.Errorf("unexpected location: %v", location) 11744 } 11745 if e, a := tc.expect, location.String(); e != a { 11746 t.Errorf("expected %q, but got %q", e, a) 11747 } 11748 } 11749 }) 11750 } 11751 } 11752 11753 func TestUpdateServiceLoadBalancerStatus(t *testing.T) { 11754 storage, statusStorage, server := newStorage(t, []api.IPFamily{api.IPv4Protocol}) 11755 defer server.Terminate(t) 11756 defer storage.Store.DestroyFunc() 11757 defer statusStorage.store.DestroyFunc() 11758 11759 ipModeVIP := api.LoadBalancerIPModeVIP 11760 ipModeProxy := api.LoadBalancerIPModeProxy 11761 ipModeDummy := api.LoadBalancerIPMode("dummy") 11762 11763 testCases := []struct { 11764 name string 11765 ipModeEnabled bool 11766 statusBeforeUpdate api.ServiceStatus 11767 newStatus api.ServiceStatus 11768 expectedStatus api.ServiceStatus 11769 expectErr bool 11770 expectedReasonForError metav1.StatusReason 11771 }{ 11772 /*LoadBalancerIPMode disabled*/ 11773 { 11774 name: "LoadBalancerIPMode disabled, ipMode not used in old, not used in new", 11775 ipModeEnabled: false, 11776 statusBeforeUpdate: api.ServiceStatus{}, 11777 newStatus: api.ServiceStatus{ 11778 LoadBalancer: api.LoadBalancerStatus{ 11779 Ingress: []api.LoadBalancerIngress{{ 11780 IP: "1.2.3.4", 11781 }}, 11782 }, 11783 }, 11784 expectedStatus: api.ServiceStatus{ 11785 LoadBalancer: api.LoadBalancerStatus{ 11786 Ingress: []api.LoadBalancerIngress{{ 11787 IP: "1.2.3.4", 11788 }}, 11789 }, 11790 }, 11791 expectErr: false, 11792 }, { 11793 name: "LoadBalancerIPMode disabled, ipMode used in old and in new", 11794 ipModeEnabled: false, 11795 statusBeforeUpdate: api.ServiceStatus{ 11796 LoadBalancer: api.LoadBalancerStatus{ 11797 Ingress: []api.LoadBalancerIngress{{ 11798 IP: "1.2.3.4", 11799 IPMode: &ipModeVIP, 11800 }}, 11801 }, 11802 }, 11803 newStatus: api.ServiceStatus{ 11804 LoadBalancer: api.LoadBalancerStatus{ 11805 Ingress: []api.LoadBalancerIngress{{ 11806 IP: "1.2.3.4", 11807 IPMode: &ipModeProxy, 11808 }}, 11809 }, 11810 }, 11811 expectedStatus: api.ServiceStatus{ 11812 LoadBalancer: api.LoadBalancerStatus{ 11813 Ingress: []api.LoadBalancerIngress{{ 11814 IP: "1.2.3.4", 11815 IPMode: &ipModeProxy, 11816 }}, 11817 }, 11818 }, 11819 expectErr: false, 11820 }, { 11821 name: "LoadBalancerIPMode disabled, ipMode not used in old, used in new", 11822 ipModeEnabled: false, 11823 statusBeforeUpdate: api.ServiceStatus{ 11824 LoadBalancer: api.LoadBalancerStatus{ 11825 Ingress: []api.LoadBalancerIngress{{ 11826 IP: "1.2.3.4", 11827 }}, 11828 }, 11829 }, 11830 newStatus: api.ServiceStatus{ 11831 LoadBalancer: api.LoadBalancerStatus{ 11832 Ingress: []api.LoadBalancerIngress{{ 11833 IP: "1.2.3.4", 11834 IPMode: &ipModeProxy, 11835 }}, 11836 }, 11837 }, 11838 expectedStatus: api.ServiceStatus{ 11839 LoadBalancer: api.LoadBalancerStatus{ 11840 Ingress: []api.LoadBalancerIngress{{ 11841 IP: "1.2.3.4", 11842 }}, 11843 }, 11844 }, 11845 expectErr: false, 11846 }, { 11847 name: "LoadBalancerIPMode disabled, ipMode used in old, not used in new", 11848 ipModeEnabled: false, 11849 statusBeforeUpdate: api.ServiceStatus{ 11850 LoadBalancer: api.LoadBalancerStatus{ 11851 Ingress: []api.LoadBalancerIngress{{ 11852 IP: "1.2.3.4", 11853 IPMode: &ipModeVIP, 11854 }}, 11855 }, 11856 }, 11857 newStatus: api.ServiceStatus{ 11858 LoadBalancer: api.LoadBalancerStatus{ 11859 Ingress: []api.LoadBalancerIngress{{ 11860 IP: "1.2.3.4", 11861 }}, 11862 }, 11863 }, 11864 expectedStatus: api.ServiceStatus{ 11865 LoadBalancer: api.LoadBalancerStatus{ 11866 Ingress: []api.LoadBalancerIngress{{ 11867 IP: "1.2.3.4", 11868 }}, 11869 }, 11870 }, 11871 expectErr: false, 11872 }, 11873 /*LoadBalancerIPMode enabled*/ 11874 { 11875 name: "LoadBalancerIPMode enabled, ipMode not used in old, not used in new", 11876 ipModeEnabled: true, 11877 statusBeforeUpdate: api.ServiceStatus{}, 11878 newStatus: api.ServiceStatus{ 11879 LoadBalancer: api.LoadBalancerStatus{ 11880 Ingress: []api.LoadBalancerIngress{{ 11881 IP: "1.2.3.4", 11882 }}, 11883 }, 11884 }, 11885 expectedStatus: api.ServiceStatus{}, 11886 expectErr: true, 11887 expectedReasonForError: metav1.StatusReasonInvalid, 11888 }, { 11889 name: "LoadBalancerIPMode enabled, ipMode used in old and in new", 11890 ipModeEnabled: true, 11891 statusBeforeUpdate: api.ServiceStatus{ 11892 LoadBalancer: api.LoadBalancerStatus{ 11893 Ingress: []api.LoadBalancerIngress{{ 11894 IP: "1.2.3.4", 11895 IPMode: &ipModeProxy, 11896 }}, 11897 }, 11898 }, 11899 newStatus: api.ServiceStatus{ 11900 LoadBalancer: api.LoadBalancerStatus{ 11901 Ingress: []api.LoadBalancerIngress{{ 11902 IP: "1.2.3.4", 11903 IPMode: &ipModeVIP, 11904 }}, 11905 }, 11906 }, 11907 expectedStatus: api.ServiceStatus{ 11908 LoadBalancer: api.LoadBalancerStatus{ 11909 Ingress: []api.LoadBalancerIngress{{ 11910 IP: "1.2.3.4", 11911 IPMode: &ipModeVIP, 11912 }}, 11913 }, 11914 }, 11915 expectErr: false, 11916 }, { 11917 name: "LoadBalancerIPMode enabled, ipMode not used in old, used in new", 11918 ipModeEnabled: true, 11919 statusBeforeUpdate: api.ServiceStatus{ 11920 LoadBalancer: api.LoadBalancerStatus{ 11921 Ingress: []api.LoadBalancerIngress{{ 11922 IP: "1.2.3.4", 11923 }}, 11924 }, 11925 }, 11926 newStatus: api.ServiceStatus{ 11927 LoadBalancer: api.LoadBalancerStatus{ 11928 Ingress: []api.LoadBalancerIngress{{ 11929 IP: "1.2.3.4", 11930 IPMode: &ipModeProxy, 11931 }}, 11932 }, 11933 }, 11934 expectedStatus: api.ServiceStatus{ 11935 LoadBalancer: api.LoadBalancerStatus{ 11936 Ingress: []api.LoadBalancerIngress{{ 11937 IP: "1.2.3.4", 11938 IPMode: &ipModeProxy, 11939 }}, 11940 }, 11941 }, 11942 expectErr: false, 11943 }, { 11944 name: "LoadBalancerIPMode enabled, ipMode used in old, not used in new", 11945 ipModeEnabled: true, 11946 statusBeforeUpdate: api.ServiceStatus{ 11947 LoadBalancer: api.LoadBalancerStatus{ 11948 Ingress: []api.LoadBalancerIngress{{ 11949 IP: "1.2.3.4", 11950 IPMode: &ipModeVIP, 11951 }}, 11952 }, 11953 }, 11954 newStatus: api.ServiceStatus{ 11955 LoadBalancer: api.LoadBalancerStatus{ 11956 Ingress: []api.LoadBalancerIngress{{ 11957 IP: "1.2.3.4", 11958 }}, 11959 }, 11960 }, 11961 expectedStatus: api.ServiceStatus{}, 11962 expectErr: true, 11963 expectedReasonForError: metav1.StatusReasonInvalid, 11964 }, { 11965 name: "LoadBalancerIPMode enabled, ipMode not used in old, invalid value used in new", 11966 ipModeEnabled: true, 11967 statusBeforeUpdate: api.ServiceStatus{ 11968 LoadBalancer: api.LoadBalancerStatus{ 11969 Ingress: []api.LoadBalancerIngress{{ 11970 IP: "1.2.3.4", 11971 }}, 11972 }, 11973 }, 11974 newStatus: api.ServiceStatus{ 11975 LoadBalancer: api.LoadBalancerStatus{ 11976 Ingress: []api.LoadBalancerIngress{{ 11977 IP: "1.2.3.4", 11978 IPMode: &ipModeDummy, 11979 }}, 11980 }, 11981 }, 11982 expectedStatus: api.ServiceStatus{}, 11983 expectErr: true, 11984 expectedReasonForError: metav1.StatusReasonInvalid, 11985 }, 11986 } 11987 11988 for _, tc := range testCases { 11989 t.Run(tc.name, func(t *testing.T) { 11990 11991 svc := svctest.MakeService("foo", svctest.SetTypeLoadBalancer) 11992 ctx := genericapirequest.NewDefaultContext() 11993 obj, err := storage.Create(ctx, svc, rest.ValidateAllObjectFunc, &metav1.CreateOptions{}) 11994 if err != nil { 11995 t.Errorf("created svc: %s", err) 11996 } 11997 defer storage.Delete(ctx, svc.Name, rest.ValidateAllObjectFunc, &metav1.DeleteOptions{}) 11998 11999 // prepare status 12000 // Test here is negative, because starting with v1.30 the feature gate is enabled by default, so we should 12001 // now disable it to do the proper test 12002 if !loadbalancerIPModeInUse(tc.statusBeforeUpdate) { 12003 featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.LoadBalancerIPMode, false) 12004 } 12005 oldSvc := obj.(*api.Service).DeepCopy() 12006 oldSvc.Status = tc.statusBeforeUpdate 12007 obj, _, err = statusStorage.Update(ctx, oldSvc.Name, rest.DefaultUpdatedObjectInfo(oldSvc), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{}) 12008 if err != nil { 12009 t.Errorf("updated status: %s", err) 12010 } 12011 12012 featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.LoadBalancerIPMode, tc.ipModeEnabled) 12013 newSvc := obj.(*api.Service).DeepCopy() 12014 newSvc.Status = tc.newStatus 12015 obj, _, err = statusStorage.Update(ctx, newSvc.Name, rest.DefaultUpdatedObjectInfo(newSvc), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{}) 12016 if err != nil { 12017 if tc.expectErr && tc.expectedReasonForError == errors.ReasonForError(err) { 12018 return 12019 } 12020 t.Errorf("updated status: %s", err) 12021 } 12022 12023 updated := obj.(*api.Service) 12024 if !reflect.DeepEqual(tc.expectedStatus, updated.Status) { 12025 t.Errorf("%v: unexpected svc status: %v", tc.name, cmp.Diff(tc.expectedStatus, updated.Status)) 12026 } 12027 }) 12028 } 12029 } 12030 12031 func loadbalancerIPModeInUse(status api.ServiceStatus) bool { 12032 for _, ing := range status.LoadBalancer.Ingress { 12033 if ing.IPMode != nil { 12034 return true 12035 } 12036 } 12037 return false 12038 }