Debian Codegraph @

pkg/endpoints/discovery/root_test.go

raw
1 /*
2 Copyright 2017 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 discovery
18
19 import (
20 "context"
21 "encoding/json"
22 "fmt"
23 "io/ioutil"
24 "net/http"
25 "net/http/httptest"
26 "testing"
27
28 "github.com/stretchr/testify/assert"
29
30 metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
31 "k8s.io/apimachinery/pkg/runtime"
32 "k8s.io/apimachinery/pkg/runtime/schema"
33 "k8s.io/apimachinery/pkg/runtime/serializer"
34 utilnet "k8s.io/apimachinery/pkg/util/net"
35 "k8s.io/apimachinery/pkg/util/sets"
36 "k8s.io/apiserver/pkg/endpoints/request"
37 )
38
39 var (
40 scheme = runtime.NewScheme()
41 codecs = serializer.NewCodecFactory(scheme)
42 )
43
44 func init() {
45 // Register Unversioned types under their own special group
46 scheme.AddUnversionedTypes(schema.GroupVersion{Group: "", Version: "v1"},
47 &metav1.Status{},
48 &metav1.APIVersions{},
49 &metav1.APIGroupList{},
50 &metav1.APIGroup{},
51 &metav1.APIResourceList{},
52 )
53 }
54
55 func decodeResponse(t *testing.T, resp *http.Response, obj interface{}) error {
56 defer resp.Body.Close()
57
58 data, err := ioutil.ReadAll(resp.Body)
59 t.Log(string(data))
60 if err != nil {
61 return err
62 }
63 if err := json.Unmarshal(data, obj); err != nil {
64 return err
65 }
66 return nil
67 }
68
69 func getGroupList(t *testing.T, server *httptest.Server) (*metav1.APIGroupList, error) {
70 resp, err := http.Get(server.URL)
71 if err != nil {
72 return nil, err
73 }
74
75 if resp.StatusCode != http.StatusOK {
76 return nil, fmt.Errorf("unexpected server response, expected %d, actual: %d", http.StatusOK, resp.StatusCode)
77 }
78
79 groupList := metav1.APIGroupList{}
80 err = decodeResponse(t, resp, &groupList)
81 return &groupList, err
82 }
83
84 func contextHandler(handler http.Handler) http.Handler {
85 return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
86 ctx := req.Context()
87 resolver := &request.RequestInfoFactory{
88 APIPrefixes: sets.NewString("api", "apis"),
89 GrouplessAPIPrefixes: sets.NewString("api"),
90 }
91 info, err := resolver.NewRequestInfo(req)
92 if err == nil {
93 ctx = request.WithRequestInfo(ctx, info)
94 }
95 req = req.WithContext(ctx)
96 handler.ServeHTTP(w, req)
97 })
98 }
99
100 func TestDiscoveryAtAPIS(t *testing.T) {
101 handler := NewRootAPIsHandler(DefaultAddresses{DefaultAddress: "192.168.1.1"}, codecs)
102
103 server := httptest.NewServer(contextHandler(handler))
104
105 groupList, err := getGroupList(t, server)
106 if err != nil {
107 t.Fatalf("unexpected error: %v", err)
108 }
109 assert.Empty(t, groupList.Groups)
110
111 // Add a Group.
112 extensionsGroupName := "extensions"
113 extensionsVersions := []metav1.GroupVersionForDiscovery{
114 {
115 GroupVersion: extensionsGroupName + "/v1",
116 Version: "v1",
117 },
118 }
119 extensionsPreferredVersion := metav1.GroupVersionForDiscovery{
120 GroupVersion: extensionsGroupName + "/preferred",
121 Version: "preferred",
122 }
123 handler.AddGroup(metav1.APIGroup{
124 Name: extensionsGroupName,
125 Versions: extensionsVersions,
126 PreferredVersion: extensionsPreferredVersion,
127 })
128
129 groupList, err = getGroupList(t, server)
130 if err != nil {
131 t.Fatalf("unexpected error: %v", err)
132 }
133
134 assert.Len(t, groupList.Groups, 1)
135 groupListGroup := groupList.Groups[0]
136 assert.Equal(t, extensionsGroupName, groupListGroup.Name)
137 assert.Equal(t, extensionsVersions, groupListGroup.Versions)
138 assert.Equal(t, extensionsPreferredVersion, groupListGroup.PreferredVersion)
139 assert.Equal(t, handler.addresses.ServerAddressByClientCIDRs(utilnet.GetClientIP(&http.Request{})), groupListGroup.ServerAddressByClientCIDRs)
140
141 // Remove the group.
142 handler.RemoveGroup(extensionsGroupName)
143 groupList, err = getGroupList(t, server)
144 if err != nil {
145 t.Fatalf("unexpected error: %v", err)
146 }
147
148 assert.Empty(t, groupList.Groups)
149 }
150
151 func TestDiscoveryOrdering(t *testing.T) {
152 handler := NewRootAPIsHandler(DefaultAddresses{DefaultAddress: "192.168.1.1"}, codecs)
153
154 server := httptest.NewServer(handler)
155 groupList, err := getGroupList(t, server)
156 if err != nil {
157 t.Fatalf("unexpected error: %v", err)
158 }
159 assert.Empty(t, groupList.Groups)
160
161 // Register three groups
162 handler.AddGroup(metav1.APIGroup{Name: "x"})
163 handler.AddGroup(metav1.APIGroup{Name: "y"})
164 handler.AddGroup(metav1.APIGroup{Name: "z"})
165 // Register three additional groups that come earlier alphabetically
166 handler.AddGroup(metav1.APIGroup{Name: "a"})
167 handler.AddGroup(metav1.APIGroup{Name: "b"})
168 handler.AddGroup(metav1.APIGroup{Name: "c"})
169 // Make sure re-adding doesn't double-register or make a group lose its place
170 handler.AddGroup(metav1.APIGroup{Name: "x"})
171
172 groupList, err = getGroupList(t, server)
173 if err != nil {
174 t.Fatalf("unexpected error: %v", err)
175 }
176
177 // Check if internal groups listers returns the same group.
178 groups, err := handler.Groups(context.TODO(), &http.Request{})
179 if err != nil {
180 t.Fatalf("unexpected error: %v", err)
181 }
182 assert.Len(t, groups, 6)
183
184 assert.Len(t, groupList.Groups, 6)
185 assert.Equal(t, "x", groupList.Groups[0].Name)
186 assert.Equal(t, "y", groupList.Groups[1].Name)
187 assert.Equal(t, "z", groupList.Groups[2].Name)
188 assert.Equal(t, "a", groupList.Groups[3].Name)
189 assert.Equal(t, "b", groupList.Groups[4].Name)
190 assert.Equal(t, "c", groupList.Groups[5].Name)
191
192 // Remove a group.
193 handler.RemoveGroup("a")
194 groupList, err = getGroupList(t, server)
195 if err != nil {
196 t.Fatalf("unexpected error: %v", err)
197 }
198 assert.Len(t, groupList.Groups, 5)
199
200 // Re-adding should move to the end.
201 handler.AddGroup(metav1.APIGroup{Name: "a"})
202 groupList, err = getGroupList(t, server)
203 if err != nil {
204 t.Fatalf("unexpected error: %v", err)
205 }
206 assert.Len(t, groupList.Groups, 6)
207 assert.Equal(t, "x", groupList.Groups[0].Name)
208 assert.Equal(t, "y", groupList.Groups[1].Name)
209 assert.Equal(t, "z", groupList.Groups[2].Name)
210 assert.Equal(t, "b", groupList.Groups[3].Name)
211 assert.Equal(t, "c", groupList.Groups[4].Name)
212 assert.Equal(t, "a", groupList.Groups[5].Name)
213 }