storage_test.go

Documentation: k8s.io/kubernetes/pkg/registry/networking/ingress/storage

     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  	"testing"
    21  
    22  	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    23  	"k8s.io/apimachinery/pkg/fields"
    24  	"k8s.io/apimachinery/pkg/labels"
    25  	"k8s.io/apimachinery/pkg/runtime"
    26  	"k8s.io/apimachinery/pkg/util/intstr"
    27  	"k8s.io/apiserver/pkg/registry/generic"
    28  	genericregistrytest "k8s.io/apiserver/pkg/registry/generic/testing"
    29  	etcd3testing "k8s.io/apiserver/pkg/storage/etcd3/testing"
    30  	_ "k8s.io/kubernetes/pkg/apis/extensions/install"
    31  	"k8s.io/kubernetes/pkg/apis/networking"
    32  	_ "k8s.io/kubernetes/pkg/apis/networking/install"
    33  	"k8s.io/kubernetes/pkg/registry/registrytest"
    34  )
    35  
    36  func newStorage(t *testing.T) (*REST, *StatusREST, *etcd3testing.EtcdTestServer) {
    37  	etcdStorage, server := registrytest.NewEtcdStorageForResource(t, networking.Resource("ingresses"))
    38  	restOptions := generic.RESTOptions{
    39  		StorageConfig:           etcdStorage,
    40  		Decorator:               generic.UndecoratedStorage,
    41  		DeleteCollectionWorkers: 1,
    42  		ResourcePrefix:          "ingresses",
    43  	}
    44  	ingressStorage, statusStorage, err := NewREST(restOptions)
    45  	if err != nil {
    46  		t.Fatalf("unexpected error from REST storage: %v", err)
    47  	}
    48  	return ingressStorage, statusStorage, server
    49  }
    50  
    51  var (
    52  	namespace           = metav1.NamespaceNone
    53  	name                = "foo-ingress"
    54  	defaultHostname     = "foo.bar.com"
    55  	defaultBackendName  = "default-backend"
    56  	defaultBackendPort  = intstr.FromInt32(80)
    57  	defaultLoadBalancer = "127.0.0.1"
    58  	defaultPath         = "/foo"
    59  	defaultPathType     = networking.PathTypeImplementationSpecific
    60  	defaultPathMap      = map[string]string{defaultPath: defaultBackendName}
    61  	defaultTLS          = []networking.IngressTLS{
    62  		{Hosts: []string{"foo.bar.com", "*.bar.com"}, SecretName: "foosecret"},
    63  	}
    64  	serviceBackend = &networking.IngressServiceBackend{
    65  		Name: "defaultbackend",
    66  		Port: networking.ServiceBackendPort{
    67  			Name:   "",
    68  			Number: 80,
    69  		},
    70  	}
    71  )
    72  
    73  type IngressRuleValues map[string]string
    74  
    75  func toHTTPIngressPaths(pathMap map[string]string) []networking.HTTPIngressPath {
    76  	httpPaths := []networking.HTTPIngressPath{}
    77  	for path, backend := range pathMap {
    78  		httpPaths = append(httpPaths, networking.HTTPIngressPath{
    79  			Path:     path,
    80  			PathType: &defaultPathType,
    81  			Backend: networking.IngressBackend{
    82  				Service: &networking.IngressServiceBackend{
    83  					Name: backend,
    84  					Port: networking.ServiceBackendPort{
    85  						Name:   defaultBackendPort.StrVal,
    86  						Number: defaultBackendPort.IntVal,
    87  					},
    88  				},
    89  			},
    90  		})
    91  	}
    92  	return httpPaths
    93  }
    94  
    95  func toIngressRules(hostRules map[string]IngressRuleValues) []networking.IngressRule {
    96  	rules := []networking.IngressRule{}
    97  	for host, pathMap := range hostRules {
    98  		rules = append(rules, networking.IngressRule{
    99  			Host: host,
   100  			IngressRuleValue: networking.IngressRuleValue{
   101  				HTTP: &networking.HTTPIngressRuleValue{
   102  					Paths: toHTTPIngressPaths(pathMap),
   103  				},
   104  			},
   105  		})
   106  	}
   107  	return rules
   108  }
   109  
   110  func newIngress(pathMap map[string]string) *networking.Ingress {
   111  	return &networking.Ingress{
   112  		ObjectMeta: metav1.ObjectMeta{
   113  			Name:      name,
   114  			Namespace: namespace,
   115  		},
   116  		Spec: networking.IngressSpec{
   117  			DefaultBackend: &networking.IngressBackend{
   118  				Service: serviceBackend.DeepCopy(),
   119  			},
   120  			Rules: toIngressRules(map[string]IngressRuleValues{
   121  				defaultHostname: pathMap,
   122  			}),
   123  			TLS: defaultTLS,
   124  		},
   125  		Status: networking.IngressStatus{
   126  			LoadBalancer: networking.IngressLoadBalancerStatus{
   127  				Ingress: []networking.IngressLoadBalancerIngress{
   128  					{IP: defaultLoadBalancer},
   129  				},
   130  			},
   131  		},
   132  	}
   133  }
   134  
   135  func validIngress() *networking.Ingress {
   136  	return newIngress(defaultPathMap)
   137  }
   138  
   139  func TestCreate(t *testing.T) {
   140  	storage, _, server := newStorage(t)
   141  	defer server.Terminate(t)
   142  	defer storage.Store.DestroyFunc()
   143  	test := genericregistrytest.New(t, storage.Store)
   144  	ingress := validIngress()
   145  	noDefaultBackendAndRules := validIngress()
   146  	noDefaultBackendAndRules.Spec.DefaultBackend.Service = &networking.IngressServiceBackend{}
   147  	noDefaultBackendAndRules.Spec.Rules = []networking.IngressRule{}
   148  	badPath := validIngress()
   149  	badPath.Spec.Rules = toIngressRules(map[string]IngressRuleValues{
   150  		"foo.bar.com": {"invalid-no-leading-slash": "svc"}})
   151  	test.TestCreate(
   152  		// valid
   153  		ingress,
   154  		noDefaultBackendAndRules,
   155  		badPath,
   156  	)
   157  }
   158  
   159  func TestUpdate(t *testing.T) {
   160  	storage, _, server := newStorage(t)
   161  	defer server.Terminate(t)
   162  	defer storage.Store.DestroyFunc()
   163  	test := genericregistrytest.New(t, storage.Store)
   164  	test.TestUpdate(
   165  		// valid
   166  		validIngress(),
   167  		// updateFunc
   168  		func(obj runtime.Object) runtime.Object {
   169  			object := obj.(*networking.Ingress)
   170  			object.Spec.Rules = toIngressRules(map[string]IngressRuleValues{
   171  				"bar.foo.com": {"/bar": defaultBackendName},
   172  			})
   173  			object.Spec.TLS = append(object.Spec.TLS, networking.IngressTLS{
   174  				Hosts:      []string{"*.google.com"},
   175  				SecretName: "googlesecret",
   176  			})
   177  			return object
   178  		},
   179  		// invalid updateFunc: ObjectMeta is not to be tampered with.
   180  		func(obj runtime.Object) runtime.Object {
   181  			object := obj.(*networking.Ingress)
   182  			object.Name = ""
   183  			return object
   184  		},
   185  
   186  		func(obj runtime.Object) runtime.Object {
   187  			object := obj.(*networking.Ingress)
   188  			object.Spec.Rules = toIngressRules(map[string]IngressRuleValues{
   189  				"foo.bar.com": {"invalid-no-leading-slash": "svc"}})
   190  			return object
   191  		},
   192  	)
   193  }
   194  
   195  func TestDelete(t *testing.T) {
   196  	storage, _, server := newStorage(t)
   197  	defer server.Terminate(t)
   198  	defer storage.Store.DestroyFunc()
   199  	test := genericregistrytest.New(t, storage.Store)
   200  	test.TestDelete(validIngress())
   201  }
   202  
   203  func TestGet(t *testing.T) {
   204  	storage, _, server := newStorage(t)
   205  	defer server.Terminate(t)
   206  	defer storage.Store.DestroyFunc()
   207  	test := genericregistrytest.New(t, storage.Store)
   208  	test.TestGet(validIngress())
   209  }
   210  
   211  func TestList(t *testing.T) {
   212  	storage, _, server := newStorage(t)
   213  	defer server.Terminate(t)
   214  	defer storage.Store.DestroyFunc()
   215  	test := genericregistrytest.New(t, storage.Store)
   216  	test.TestList(validIngress())
   217  }
   218  
   219  func TestWatch(t *testing.T) {
   220  	storage, _, server := newStorage(t)
   221  	defer server.Terminate(t)
   222  	defer storage.Store.DestroyFunc()
   223  	test := genericregistrytest.New(t, storage.Store)
   224  	test.TestWatch(
   225  		validIngress(),
   226  		// matching labels
   227  		[]labels.Set{},
   228  		// not matching labels
   229  		[]labels.Set{
   230  			{"a": "c"},
   231  			{"foo": "bar"},
   232  		},
   233  		// matching fields
   234  		[]fields.Set{
   235  			{"metadata.name": name},
   236  		},
   237  		// not matching fields
   238  		[]fields.Set{
   239  			{"metadata.name": "bar"},
   240  			{"name": name},
   241  		},
   242  	)
   243  }
   244  
   245  func TestShortNames(t *testing.T) {
   246  	storage, _, server := newStorage(t)
   247  	defer server.Terminate(t)
   248  	defer storage.Store.DestroyFunc()
   249  	expected := []string{"ing"}
   250  	registrytest.AssertShortNames(t, storage, expected)
   251  }
   252  
   253  // TODO TestUpdateStatus
   254
View as plain text