Debian Codegraph @

pkg/endpoints/handlers/helpers_test.go

raw
1 /*
2 Copyright 2019 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 handlers
18
19 import (
20 "context"
21 "fmt"
22 "net/http"
23 "net/url"
24 "testing"
25
26 "github.com/stretchr/testify/assert"
27 "k8s.io/apiserver/pkg/endpoints/request"
28 )
29
30 func TestLazyTruncatedUserAgent(t *testing.T) {
31 req := &http.Request{}
32 req.Header = http.Header{}
33
34 ua := "short-agent"
35 req.Header.Set("User-Agent", ua)
36 uaNotTruncated := &lazyTruncatedUserAgent{req}
37 assert.Equal(t, ua, fmt.Sprintf("%v", uaNotTruncated))
38
39 ua = ""
40 for i := 0; i < maxUserAgentLength*2; i++ {
41 ua = ua + "a"
42 }
43 req.Header.Set("User-Agent", ua)
44 uaTruncated := &lazyTruncatedUserAgent{req}
45 assert.NotEqual(t, ua, fmt.Sprintf("%v", uaTruncated))
46
47 usUnknown := &lazyTruncatedUserAgent{}
48 assert.Equal(t, "unknown", fmt.Sprintf("%v", usUnknown))
49 }
50
51 func TestLazyClientIP(t *testing.T) {
52 req := &http.Request{}
53 req.Header = http.Header{}
54
55 ip := "127.0.0.1"
56 req.Header.Set("X-Forwarded-For", ip)
57
58 clientIPWithReq := &lazyClientIP{req}
59 assert.Equal(t, ip, fmt.Sprintf("%v", clientIPWithReq))
60
61 clientIPWithoutReq := &lazyClientIP{}
62 assert.Equal(t, "unknown", fmt.Sprintf("%v", clientIPWithoutReq))
63 }
64
65 func TestLazyAccept(t *testing.T) {
66 req := &http.Request{}
67 req.Header = http.Header{}
68
69 accept := "application/json"
70 req.Header.Set("Accept", accept)
71
72 acceptWithReq := &lazyAccept{req}
73 assert.Equal(t, accept, fmt.Sprintf("%v", acceptWithReq))
74
75 acceptWithoutReq := &lazyAccept{}
76 assert.Equal(t, "unknown", fmt.Sprintf("%v", acceptWithoutReq))
77 }
78
79 func TestLazyVerb(t *testing.T) {
80 assert.Equal(t, "unknown", fmt.Sprintf("%v", &lazyVerb{}))
81
82 u, _ := url.Parse("?watch=true")
83 req := &http.Request{Method: "GET", URL: u}
84 verbWithReq := &lazyVerb{req: req}
85 assert.Equal(t, "WATCH", fmt.Sprintf("%v", verbWithReq))
86 }
87
88 func TestLazyApiGroup(t *testing.T) {
89 assert.Equal(t, "unknown", fmt.Sprintf("%v", &lazyAPIGroup{}))
90
91 scopeWithEmptyReq := &lazyAPIGroup{&http.Request{}}
92 assert.Equal(t, "unknown", fmt.Sprintf("%v", scopeWithEmptyReq))
93
94 req := &http.Request{}
95 ctx := request.WithRequestInfo(context.TODO(), &request.RequestInfo{APIGroup: "apps"})
96 scopeWithReq := &lazyAPIGroup{req: req.WithContext(ctx)}
97 assert.Equal(t, "apps", fmt.Sprintf("%v", scopeWithReq))
98 }
99
100 func TestLazyApiVersion(t *testing.T) {
101 assert.Equal(t, "unknown", fmt.Sprintf("%v", &lazyAPIVersion{}))
102
103 scopeWithEmptyReq := &lazyAPIVersion{&http.Request{}}
104 assert.Equal(t, "unknown", fmt.Sprintf("%v", scopeWithEmptyReq))
105
106 req := &http.Request{}
107 ctx := request.WithRequestInfo(context.TODO(), &request.RequestInfo{APIVersion: "v1"})
108 scopeWithReq := &lazyAPIVersion{req: req.WithContext(ctx)}
109 assert.Equal(t, "v1", fmt.Sprintf("%v", scopeWithReq))
110 }
111
112 func TestLazyName(t *testing.T) {
113 assert.Equal(t, "unknown", fmt.Sprintf("%v", &lazyName{}))
114
115 scopeWithEmptyReq := &lazyName{&http.Request{}}
116 assert.Equal(t, "unknown", fmt.Sprintf("%v", scopeWithEmptyReq))
117
118 req := &http.Request{}
119 ctx := request.WithRequestInfo(context.TODO(), &request.RequestInfo{Name: "jaeger-76d45d6876-vqp8t"})
120 scopeWithReq := &lazyName{req: req.WithContext(ctx)}
121 assert.Equal(t, "jaeger-76d45d6876-vqp8t", fmt.Sprintf("%v", scopeWithReq))
122 }
123
124 func TestLazySubresource(t *testing.T) {
125 assert.Equal(t, "unknown", fmt.Sprintf("%v", &lazySubresource{}))
126
127 scopeWithEmptyReq := &lazySubresource{&http.Request{}}
128 assert.Equal(t, "unknown", fmt.Sprintf("%v", scopeWithEmptyReq))
129
130 req := &http.Request{}
131 ctx := request.WithRequestInfo(context.TODO(), &request.RequestInfo{Subresource: "binding"})
132 scopeWithReq := &lazySubresource{req: req.WithContext(ctx)}
133 assert.Equal(t, "binding", fmt.Sprintf("%v", scopeWithReq))
134 }
135
136 func TestLazyNamespace(t *testing.T) {
137 assert.Equal(t, "unknown", fmt.Sprintf("%v", &lazyNamespace{}))
138
139 scopeWithEmptyReq := &lazyNamespace{&http.Request{}}
140 assert.Equal(t, "unknown", fmt.Sprintf("%v", scopeWithEmptyReq))
141
142 req := &http.Request{}
143 ctx := request.WithRequestInfo(context.TODO(), &request.RequestInfo{Namespace: "jaeger"})
144 scopeWithReq := &lazyNamespace{req: req.WithContext(ctx)}
145 assert.Equal(t, "jaeger", fmt.Sprintf("%v", scopeWithReq))
146 }
147
148 func TestLazyResource(t *testing.T) {
149 assert.Equal(t, "unknown", fmt.Sprintf("%v", &lazyResource{}))
150
151 resourceWithEmptyReq := &lazyResource{&http.Request{}}
152 assert.Equal(t, "unknown", fmt.Sprintf("%v", resourceWithEmptyReq))
153
154 req := &http.Request{}
155 ctx := request.WithRequestInfo(context.TODO(), &request.RequestInfo{Resource: "resource"})
156 resourceWithReq := &lazyResource{req: req.WithContext(ctx)}
157 assert.Equal(t, "resource", fmt.Sprintf("%v", resourceWithReq))
158 }
159
160 func TestLazyScope(t *testing.T) {
161 assert.Equal(t, "unknown", fmt.Sprintf("%v", &lazyScope{}))
162
163 scopeWithEmptyReq := &lazyScope{&http.Request{}}
164 assert.Equal(t, "unknown", fmt.Sprintf("%v", scopeWithEmptyReq))
165
166 req := &http.Request{}
167 ctx := request.WithRequestInfo(context.TODO(), &request.RequestInfo{Namespace: "ns"})
168 scopeWithReq := &lazyScope{req: req.WithContext(ctx)}
169 assert.Equal(t, "namespace", fmt.Sprintf("%v", scopeWithReq))
170 }