Skip to content

Commit 47eafd8

Browse files
author
Eric Abramov
committed
Align test structure
1 parent a76edb0 commit 47eafd8

File tree

1 file changed

+143
-170
lines changed

1 file changed

+143
-170
lines changed

‎pkg/webhook/admission/validator_test.go

Lines changed: 143 additions & 170 deletions
Original file line numberDiff line numberDiff line change
@@ -18,233 +18,206 @@ import (
1818

1919
var _ = Describe("validatingHandler", func() {
2020
Describe("Handle", func() {
21+
It("should return 200 in response when create succeeds", func() {
2122

22-
When("create succeeds", func() {
23-
It("should return allowed in response", func() {
23+
handler := createSucceedingValidatingHandler()
2424

25-
handler := createSucceedingValidatingHandler()
26-
27-
response := handler.Handle(context.TODO(), Request{
28-
AdmissionRequest: v1beta1.AdmissionRequest{
29-
Operation: v1beta1.Create,
30-
Object: runtime.RawExtension{
31-
Raw: []byte("{}"),
32-
Object: handler.validator,
33-
},
25+
response := handler.Handle(context.TODO(), Request{
26+
AdmissionRequest: v1beta1.AdmissionRequest{
27+
Operation: v1beta1.Create,
28+
Object: runtime.RawExtension{
29+
Raw: []byte("{}"),
30+
Object: handler.validator,
3431
},
35-
})
36-
Expect(response.Allowed).Should(BeTrue())
37-
Expect(response.Result.Code).Should(Equal(int32(http.StatusOK)))
32+
},
3833
})
34+
Expect(response.Allowed).Should(BeTrue())
35+
Expect(response.Result.Code).Should(Equal(int32(http.StatusOK)))
3936
})
4037

41-
When("create fails on decode", func() {
42-
It("should return 400 in response", func() {
43-
//TODO
44-
})
38+
It("should return 400 in response when create fails on decode", func() {
39+
//TODO
4540
})
4641

47-
When("ValidateCreate returns APIStatus error", func() {
48-
It("should return Status.Code and embed the Status object from APIStatus in the response", func() {
42+
It("should return response built with the Status object when ValidateCreate returns APIStatus error", func() {
4943

50-
handler, expectedError := createValidatingHandlerWhichReturnsStatusError()
44+
handler, expectedError := createValidatingHandlerWhichReturnsStatusError()
5145

52-
response := handler.Handle(context.TODO(), Request{
53-
AdmissionRequest: v1beta1.AdmissionRequest{
54-
Operation: v1beta1.Create,
55-
Object: runtime.RawExtension{
56-
Raw: []byte("{}"),
57-
Object: handler.validator,
58-
},
46+
response := handler.Handle(context.TODO(), Request{
47+
AdmissionRequest: v1beta1.AdmissionRequest{
48+
Operation: v1beta1.Create,
49+
Object: runtime.RawExtension{
50+
Raw: []byte("{}"),
51+
Object: handler.validator,
5952
},
60-
})
61-
Expect(response.Allowed).Should(BeFalse())
53+
},
54+
})
55+
Expect(response.Allowed).Should(BeFalse())
6256

63-
apiStatus, ok := expectedError.(apierrs.APIStatus)
64-
Expect(ok).Should(BeTrue())
65-
Expect(response.Result.Code).Should(Equal(apiStatus.Status().Code))
66-
Expect(*response.Result).Should(Equal(apiStatus.Status()))
57+
apiStatus, ok := expectedError.(apierrs.APIStatus)
58+
Expect(ok).Should(BeTrue())
59+
Expect(response.Result.Code).Should(Equal(apiStatus.Status().Code))
60+
Expect(*response.Result).Should(Equal(apiStatus.Status()))
6761

68-
})
6962
})
7063

71-
When("ValidateCreate returns any error", func() {
72-
It("should return 403 and embed the error message in a generated Status object in the response", func() {
64+
It("should return 403 response when ValidateCreate returns non-APIStatus error", func() {
7365

74-
handler, expectedError := createValidatingHandlerWhichReturnsRegularError()
66+
handler, expectedError := createValidatingHandlerWhichReturnsRegularError()
7567

76-
response := handler.Handle(context.TODO(), Request{
77-
AdmissionRequest: v1beta1.AdmissionRequest{
78-
Operation: v1beta1.Create,
79-
Object: runtime.RawExtension{
80-
Raw: []byte("{}"),
81-
Object: handler.validator,
82-
},
68+
response := handler.Handle(context.TODO(), Request{
69+
AdmissionRequest: v1beta1.AdmissionRequest{
70+
Operation: v1beta1.Create,
71+
Object: runtime.RawExtension{
72+
Raw: []byte("{}"),
73+
Object: handler.validator,
8374
},
84-
})
85-
Expect(response.Allowed).Should(BeFalse())
86-
Expect(response.Result.Code).Should(Equal(int32(http.StatusForbidden)))
87-
Expect(string(response.Result.Reason)).Should(Equal(expectedError.Error()))
88-
75+
},
8976
})
77+
Expect(response.Allowed).Should(BeFalse())
78+
Expect(response.Result.Code).Should(Equal(int32(http.StatusForbidden)))
79+
Expect(string(response.Result.Reason)).Should(Equal(expectedError.Error()))
80+
9081
})
9182

92-
When("update succeeds", func() {
93-
It("should return allowed in response", func() {
94-
95-
handler := createSucceedingValidatingHandler()
96-
97-
response := handler.Handle(context.TODO(), Request{
98-
AdmissionRequest: v1beta1.AdmissionRequest{
99-
Operation: v1beta1.Update,
100-
Object: runtime.RawExtension{
101-
Raw: []byte("{}"),
102-
Object: handler.validator,
103-
},
104-
OldObject: runtime.RawExtension{
105-
Raw: []byte("{}"),
106-
Object: handler.validator,
107-
},
83+
It("should return 200 in response when update succeeds", func() {
84+
85+
handler := createSucceedingValidatingHandler()
86+
87+
response := handler.Handle(context.TODO(), Request{
88+
AdmissionRequest: v1beta1.AdmissionRequest{
89+
Operation: v1beta1.Update,
90+
Object: runtime.RawExtension{
91+
Raw: []byte("{}"),
92+
Object: handler.validator,
93+
},
94+
OldObject: runtime.RawExtension{
95+
Raw: []byte("{}"),
96+
Object: handler.validator,
10897
},
109-
})
110-
Expect(response.Allowed).Should(BeTrue())
111-
Expect(response.Result.Code).Should(Equal(int32(http.StatusOK)))
98+
},
11299
})
100+
Expect(response.Allowed).Should(BeTrue())
101+
Expect(response.Result.Code).Should(Equal(int32(http.StatusOK)))
113102
})
114103

115-
When("update fails on decoding new object", func() {
116-
It("should return 400 in response", func() {
117-
//TODO
118-
})
104+
It("should return 400 in response when update fails on decoding new object", func() {
105+
//TODO
119106
})
120107

121-
When("update fails on decoding old object", func() {
122-
It("should return 400 in response", func() {
123-
//TODO
124-
})
108+
It("should return 400 in response when update fails on decoding old object", func() {
109+
//TODO
125110
})
126111

127-
When("ValidateUpdate returns APIStatus error", func() {
128-
It("should return Status.Code and embed the Status object from APIStatus in the response", func() {
129-
130-
handler, expectedError := createValidatingHandlerWhichReturnsStatusError()
131-
132-
response := handler.Handle(context.TODO(), Request{
133-
AdmissionRequest: v1beta1.AdmissionRequest{
134-
Operation: v1beta1.Update,
135-
Object: runtime.RawExtension{
136-
Raw: []byte("{}"),
137-
Object: handler.validator,
138-
},
139-
OldObject: runtime.RawExtension{
140-
Raw: []byte("{}"),
141-
Object: handler.validator,
142-
},
143-
},
144-
})
145-
Expect(response.Allowed).Should(BeFalse())
112+
It("should return response built with the Status object when ValidateUpdate returns APIStatus error", func() {
146113

147-
apiStatus, ok := expectedError.(apierrs.APIStatus)
148-
Expect(ok).Should(BeTrue())
149-
Expect(response.Result.Code).Should(Equal(apiStatus.Status().Code))
150-
Expect(*response.Result).Should(Equal(apiStatus.Status()))
114+
handler, expectedError := createValidatingHandlerWhichReturnsStatusError()
151115

116+
response := handler.Handle(context.TODO(), Request{
117+
AdmissionRequest: v1beta1.AdmissionRequest{
118+
Operation: v1beta1.Update,
119+
Object: runtime.RawExtension{
120+
Raw: []byte("{}"),
121+
Object: handler.validator,
122+
},
123+
OldObject: runtime.RawExtension{
124+
Raw: []byte("{}"),
125+
Object: handler.validator,
126+
},
127+
},
152128
})
129+
Expect(response.Allowed).Should(BeFalse())
130+
131+
apiStatus, ok := expectedError.(apierrs.APIStatus)
132+
Expect(ok).Should(BeTrue())
133+
Expect(response.Result.Code).Should(Equal(apiStatus.Status().Code))
134+
Expect(*response.Result).Should(Equal(apiStatus.Status()))
135+
153136
})
154137

155-
When("ValidateUpdate returns any error", func() {
156-
It("should return 403 and embed the error message in a generated Status object in the response", func() {
157-
158-
handler, expectedError := createValidatingHandlerWhichReturnsRegularError()
159-
160-
response := handler.Handle(context.TODO(), Request{
161-
AdmissionRequest: v1beta1.AdmissionRequest{
162-
Operation: v1beta1.Update,
163-
Object: runtime.RawExtension{
164-
Raw: []byte("{}"),
165-
Object: handler.validator,
166-
},
167-
OldObject: runtime.RawExtension{
168-
Raw: []byte("{}"),
169-
Object: handler.validator,
170-
},
171-
},
172-
})
173-
Expect(response.Allowed).Should(BeFalse())
174-
Expect(response.Result.Code).Should(Equal(int32(http.StatusForbidden)))
175-
Expect(string(response.Result.Reason)).Should(Equal(expectedError.Error()))
138+
It("should return 403 response when ValidateUpdate returns non-APIStatus error", func() {
176139

140+
handler, expectedError := createValidatingHandlerWhichReturnsRegularError()
141+
142+
response := handler.Handle(context.TODO(), Request{
143+
AdmissionRequest: v1beta1.AdmissionRequest{
144+
Operation: v1beta1.Update,
145+
Object: runtime.RawExtension{
146+
Raw: []byte("{}"),
147+
Object: handler.validator,
148+
},
149+
OldObject: runtime.RawExtension{
150+
Raw: []byte("{}"),
151+
Object: handler.validator,
152+
},
153+
},
177154
})
155+
Expect(response.Allowed).Should(BeFalse())
156+
Expect(response.Result.Code).Should(Equal(int32(http.StatusForbidden)))
157+
Expect(string(response.Result.Reason)).Should(Equal(expectedError.Error()))
158+
178159
})
179160

180-
When("delete succeeds", func() {
181-
It("should return allowed in response", func() {
161+
It("should return 200 in response when delete succeeds", func() {
182162

183-
handler := createSucceedingValidatingHandler()
163+
handler := createSucceedingValidatingHandler()
184164

185-
response := handler.Handle(context.TODO(), Request{
186-
AdmissionRequest: v1beta1.AdmissionRequest{
187-
Operation: v1beta1.Delete,
188-
OldObject: runtime.RawExtension{
189-
Raw: []byte("{}"),
190-
Object: handler.validator,
191-
},
165+
response := handler.Handle(context.TODO(), Request{
166+
AdmissionRequest: v1beta1.AdmissionRequest{
167+
Operation: v1beta1.Delete,
168+
OldObject: runtime.RawExtension{
169+
Raw: []byte("{}"),
170+
Object: handler.validator,
192171
},
193-
})
194-
Expect(response.Allowed).Should(BeTrue())
195-
Expect(response.Result.Code).Should(Equal(int32(http.StatusOK)))
172+
},
196173
})
174+
Expect(response.Allowed).Should(BeTrue())
175+
Expect(response.Result.Code).Should(Equal(int32(http.StatusOK)))
197176
})
198177

199-
When("delete fails on decode", func() {
200-
It("should return 400 in response", func() {
201-
//TODO
202-
})
178+
It("should return 400 in response when delete fails on decode", func() {
179+
//TODO
203180
})
204181

205-
When("ValidateDelete returns APIStatus error", func() {
206-
It("should return Status.Code and embed the Status object from APIStatus in the response", func() {
182+
It("should return response built with the Status object when ValidateDelete returns APIStatus error", func() {
207183

208-
handler, expectedError := createValidatingHandlerWhichReturnsStatusError()
184+
handler, expectedError := createValidatingHandlerWhichReturnsStatusError()
209185

210-
response := handler.Handle(context.TODO(), Request{
211-
AdmissionRequest: v1beta1.AdmissionRequest{
212-
Operation: v1beta1.Delete,
213-
OldObject: runtime.RawExtension{
214-
Raw: []byte("{}"),
215-
Object: handler.validator,
216-
},
186+
response := handler.Handle(context.TODO(), Request{
187+
AdmissionRequest: v1beta1.AdmissionRequest{
188+
Operation: v1beta1.Delete,
189+
OldObject: runtime.RawExtension{
190+
Raw: []byte("{}"),
191+
Object: handler.validator,
217192
},
218-
})
219-
Expect(response.Allowed).Should(BeFalse())
193+
},
194+
})
195+
Expect(response.Allowed).Should(BeFalse())
220196

221-
apiStatus, ok := expectedError.(apierrs.APIStatus)
222-
Expect(ok).Should(BeTrue())
223-
Expect(response.Result.Code).Should(Equal(apiStatus.Status().Code))
224-
Expect(*response.Result).Should(Equal(apiStatus.Status()))
197+
apiStatus, ok := expectedError.(apierrs.APIStatus)
198+
Expect(ok).Should(BeTrue())
199+
Expect(response.Result.Code).Should(Equal(apiStatus.Status().Code))
200+
Expect(*response.Result).Should(Equal(apiStatus.Status()))
225201

226-
})
227202
})
228203

229-
When("ValidateDelete returns any error", func() {
230-
It("should return 403 and embed the error message in a generated Status object in the response", func() {
204+
It("should return 403 response when ValidateDelete returns non-APIStatus error", func() {
231205

232-
handler, expectedError := createValidatingHandlerWhichReturnsRegularError()
206+
handler, expectedError := createValidatingHandlerWhichReturnsRegularError()
233207

234-
response := handler.Handle(context.TODO(), Request{
235-
AdmissionRequest: v1beta1.AdmissionRequest{
236-
Operation: v1beta1.Delete,
237-
OldObject: runtime.RawExtension{
238-
Raw: []byte("{}"),
239-
Object: handler.validator,
240-
},
208+
response := handler.Handle(context.TODO(), Request{
209+
AdmissionRequest: v1beta1.AdmissionRequest{
210+
Operation: v1beta1.Delete,
211+
OldObject: runtime.RawExtension{
212+
Raw: []byte("{}"),
213+
Object: handler.validator,
241214
},
242-
})
243-
Expect(response.Allowed).Should(BeFalse())
244-
Expect(response.Result.Code).Should(Equal(int32(http.StatusForbidden)))
245-
Expect(string(response.Result.Reason)).Should(Equal(expectedError.Error()))
246-
215+
},
247216
})
217+
Expect(response.Allowed).Should(BeFalse())
218+
Expect(response.Result.Code).Should(Equal(int32(http.StatusForbidden)))
219+
Expect(string(response.Result.Reason)).Should(Equal(expectedError.Error()))
220+
248221
})
249222
})
250223
})

0 commit comments

Comments
 (0)