}

	if service.Spec.Type == api.ServiceTypeExternalName && len(service.Spec.ExternalIPs) > 0 {
		warnings = append(warnings, fmt.Sprintf("spec.externalIPs is ignored when spec.type is %q", api.ServiceTypeExternalName))
	}
	if service.Spec.Type != api.ServiceTypeExternalName && service.Spec.ExternalName != "" {

			Type: api.ServiceTypeNodePort,
		},
	})
	checkExternallyAccessible(false, &api.Service{
		Spec: api.ServiceSpec{
			Type: api.ServiceTypeExternalName,
		},
	})
	checkExternallyAccessible(false, &api.Service{
		Spec: api.ServiceSpec{
			Type:        api.ServiceTypeExternalName,
			ExternalIPs: []string{"1.2.3.4"},
		},
	})
}

func TestRequestsOnlyLocalTraffic(t *testing.T) {

			Type: v1.ServiceTypeNodePort,
		},
	})
	checkExternallyAccessible(false, &v1.Service{
		Spec: v1.ServiceSpec{
			Type: v1.ServiceTypeExternalName,
		},
	})
	checkExternallyAccessible(false, &v1.Service{
		Spec: v1.ServiceSpec{
			Type:        v1.ServiceTypeExternalName,
			ExternalIPs: []string{"1.2.3.4"},
		},
	})
}

func TestExternalPolicyLocal(t *testing.T) {

	// CASE A:
	// Update service from ExternalName to non-ExternalName, should initialize ClusterIP.
	if oldService.Spec.Type == api.ServiceTypeExternalName && service.Spec.Type != api.ServiceTypeExternalName {
		allocated, err := al.allocClusterIPs(service, dryRun)
		return allocated, nil, err
	}

	// if headless service then we bail out early (no clusterIPs management needed)

		klog.V(3).InfoS("Skipping service due to cluster IP", "service", klog.KObj(service), "clusterIP", service.Spec.ClusterIP)
		return true
	}
	// Even if ClusterIP is set, ServiceTypeExternalName services don't get proxied
	if service.Spec.Type == v1.ServiceTypeExternalName {
		klog.V(3).InfoS("Skipping service due to Type=ExternalName", "service", klog.KObj(service))
		return true
	}
	return false
}

		},
		Spec: corev1.ServiceSpec{
			Ports: []corev1.ServicePort{
				{
					Name:     "http",
					Port:     80,
					Protocol: corev1.ProtocolTCP,
				},
			},
			Type:         corev1.ServiceTypeExternalName,
			ExternalName: "google.com",
		},
	}

	service := ConvertService(extSvc, domainSuffix, clusterID, nil)
	if service == nil {
		t.Fatalf("could not convert external service")
	}

		if err != nil {
			return nil, err
		}
		return &url.URL{
			Scheme: "https",
			Host:   net.JoinHostPort(svc.Spec.ClusterIP, fmt.Sprintf("%d", svcPort.Port)),
		}, nil
	case svc.Spec.Type == v1.ServiceTypeExternalName:
		return &url.URL{
			Scheme: "https",
			Host:   net.JoinHostPort(svc.Spec.ExternalName, fmt.Sprintf("%d", port)),
		}, nil
	default:
		return nil, fmt.Errorf("unsupported service type %q", svc.Spec.Type)

	svc.Spec.InternalTrafficPolicy = &internalTrafficPolicy
}

// SetTypeExternalName sets the service type to ExternalName and clears other fields.
func SetTypeExternalName(svc *api.Service) {
	svc.Spec.Type = api.ServiceTypeExternalName
	svc.Spec.ExternalName = "example.com"
	svc.Spec.ExternalTrafficPolicy = ""
	svc.Spec.ClusterIP = ""
	svc.Spec.ClusterIPs = nil
	svc.Spec.AllocateLoadBalancerNodePorts = nil
	svc.Spec.InternalTrafficPolicy = nil

	if ingressService != "" {
		svc := s.services.Get(ingressService, IngressNamespace)
		if svc == nil {
			return nil
		}

		if svc.Spec.Type == corev1.ServiceTypeExternalName {
			addrs = append(addrs, svc.Spec.ExternalName)

			return addrs
		}

		for _, ip := range svc.Status.LoadBalancer.Ingress {
			if ip.IP == "" {
				addrs = append(addrs, ip.Hostname)

		},
		{
			name: "external name",
			services: []*v1.Service{
				{
					ObjectMeta: metav1.ObjectMeta{Namespace: "one", Name: "alfa"},
					Spec: v1.ServiceSpec{
						Type:         v1.ServiceTypeExternalName,
						ExternalName: "foo.bar.com",
					},
				},
			},
			endpoints: nil,

			clusterMode:  expectation{url: "https://foo.bar.com:443"},
			endpointMode: expectation{error: true},
		},