github.com/google/martian/v3@v3.3.3/fifo/fifo_group_test.go (about) 1 // Copyright 2015 Google Inc. All rights reserved. 2 // 3 // Licensed under the Apache License, Version 2.0 (the "License"); 4 // you may not use this file except in compliance with the License. 5 // You may obtain a copy of the License at 6 // 7 // http://www.apache.org/licenses/LICENSE-2.0 8 // 9 // Unless required by applicable law or agreed to in writing, software 10 // distributed under the License is distributed on an "AS IS" BASIS, 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 // See the License for the specific language governing permissions and 13 // limitations under the License. 14 15 package fifo 16 17 import ( 18 "errors" 19 "fmt" 20 "net/http" 21 "reflect" 22 "testing" 23 24 "github.com/google/martian/v3" 25 "github.com/google/martian/v3/martiantest" 26 "github.com/google/martian/v3/parse" 27 "github.com/google/martian/v3/proxyutil" 28 "github.com/google/martian/v3/verify" 29 30 _ "github.com/google/martian/v3/header" 31 ) 32 33 func TestGroupFromJSON(t *testing.T) { 34 msg := []byte(`{ 35 "fifo.Group": { 36 "scope": ["request", "response"], 37 "aggregateErrors": true, 38 "modifiers": [ 39 { 40 "header.Modifier": { 41 "scope": ["request", "response"], 42 "name": "X-Testing", 43 "value": "true" 44 } 45 }, 46 { 47 "header.Modifier": { 48 "scope": ["request", "response"], 49 "name": "Y-Testing", 50 "value": "true" 51 } 52 } 53 ] 54 } 55 }`) 56 57 r, err := parse.FromJSON(msg) 58 if err != nil { 59 t.Fatalf("parse.FromJSON(): got %v, want no error", err) 60 } 61 62 reqmod := r.RequestModifier() 63 if reqmod == nil { 64 t.Fatal("reqmod: got nil, want not nil") 65 } 66 req, err := http.NewRequest("GET", "http://example.com", nil) 67 if err != nil { 68 t.Fatalf("http.NewRequest(): got %v, want no error", err) 69 } 70 if err := reqmod.ModifyRequest(req); err != nil { 71 t.Fatalf("ModifyRequest(): got %v, want no error", err) 72 } 73 if got, want := req.Header.Get("X-Testing"), "true"; got != want { 74 t.Errorf("req.Header.Get(%q): got %q, want %q", "X-Testing", got, want) 75 } 76 if got, want := req.Header.Get("Y-Testing"), "true"; got != want { 77 t.Errorf("req.Header.Get(%q): got %q, want %q", "Y-Testing", got, want) 78 } 79 80 resmod := r.ResponseModifier() 81 if resmod == nil { 82 t.Fatal("resmod: got nil, want not nil") 83 } 84 res := proxyutil.NewResponse(200, nil, req) 85 if err := resmod.ModifyResponse(res); err != nil { 86 t.Fatalf("ModifyResponse(): got %v, want no error", err) 87 } 88 if got, want := res.Header.Get("X-Testing"), "true"; got != want { 89 t.Errorf("res.Header.Get(%q): got %q, want %q", "X-Testing", got, want) 90 } 91 if got, want := res.Header.Get("Y-Testing"), "true"; got != want { 92 t.Errorf("res.Header.Get(%q): got %q, want %q", "Y-Testing", got, want) 93 } 94 } 95 96 func TestModifyRequest(t *testing.T) { 97 fg := NewGroup() 98 tm := martiantest.NewModifier() 99 100 fg.AddRequestModifier(tm) 101 102 req, err := http.NewRequest("GET", "/", nil) 103 if err != nil { 104 t.Fatalf("http.NewRequest(): got %v, want no error", err) 105 } 106 if err := fg.ModifyRequest(req); err != nil { 107 t.Fatalf("fg.ModifyRequest(): got %v, want no error", err) 108 } 109 if !tm.RequestModified() { 110 t.Error("tm.RequestModified(): got false, want true") 111 } 112 } 113 114 func TestModifyRequestHaltsOnError(t *testing.T) { 115 fg := NewGroup() 116 117 reqerr := errors.New("request error") 118 tm := martiantest.NewModifier() 119 tm.RequestError(reqerr) 120 fg.AddRequestModifier(tm) 121 122 tm2 := martiantest.NewModifier() 123 fg.AddRequestModifier(tm2) 124 125 req, err := http.NewRequest("GET", "http://example.com/", nil) 126 if err != nil { 127 t.Fatalf("http.NewRequest(): got %v, want no error", err) 128 } 129 if err := fg.ModifyRequest(req); err != reqerr { 130 t.Fatalf("fg.ModifyRequest(): got %v, want %v", err, reqerr) 131 } 132 133 if tm2.RequestModified() { 134 t.Error("tm2.RequestModified(): got true, want false") 135 } 136 } 137 138 func TestModifyRequestAggregatesErrors(t *testing.T) { 139 fg := NewGroup() 140 fg.SetAggregateErrors(true) 141 142 reqerr1 := errors.New("1. request error") 143 tm := martiantest.NewModifier() 144 tm.RequestError(reqerr1) 145 fg.AddRequestModifier(tm) 146 147 tm2 := martiantest.NewModifier() 148 reqerr2 := errors.New("2. request error") 149 tm2.RequestError(reqerr2) 150 fg.AddRequestModifier(tm2) 151 152 req, err := http.NewRequest("GET", "http://example.com/", nil) 153 if err != nil { 154 t.Fatalf("http.NewRequest(): got %v, want no error", err) 155 } 156 157 merr := martian.NewMultiError() 158 merr.Add(reqerr1) 159 merr.Add(reqerr2) 160 161 if err := fg.ModifyRequest(req); err == nil { 162 t.Fatalf("fg.ModifyRequest(): got %v, want not nil", err) 163 } 164 if err := fg.ModifyRequest(req); err.Error() != merr.Error() { 165 t.Fatalf("fg.ModifyRequest(): got %v, want %v", err, merr) 166 } 167 168 if err, want := fg.ModifyRequest(req), "1. request error\n2. request error"; err.Error() != want { 169 t.Fatalf("fg.ModifyRequest(): got %v, want %v", err, want) 170 } 171 } 172 173 func TestModifyResponse(t *testing.T) { 174 fg := NewGroup() 175 tm := martiantest.NewModifier() 176 177 fg.AddResponseModifier(tm) 178 179 res := proxyutil.NewResponse(200, nil, nil) 180 if err := fg.ModifyResponse(res); err != nil { 181 t.Fatalf("fg.ModifyResponse(): got %v, want no error", err) 182 } 183 if !tm.ResponseModified() { 184 t.Error("tm.ResponseModified(): got false, want true") 185 } 186 } 187 188 func TestModifyResponseHaltsOnError(t *testing.T) { 189 fg := NewGroup() 190 191 reserr := errors.New("request error") 192 tm := martiantest.NewModifier() 193 tm.ResponseError(reserr) 194 fg.AddResponseModifier(tm) 195 196 tm2 := martiantest.NewModifier() 197 fg.AddResponseModifier(tm2) 198 199 res := proxyutil.NewResponse(200, nil, nil) 200 if err := fg.ModifyResponse(res); err != reserr { 201 t.Fatalf("fg.ModifyResponse(): got %v, want %v", err, reserr) 202 } 203 204 if tm2.ResponseModified() { 205 t.Error("tm2.ResponseModified(): got true, want false") 206 } 207 } 208 209 func TestModifyResponseAggregatesErrors(t *testing.T) { 210 fg := NewGroup() 211 fg.SetAggregateErrors(true) 212 213 reserr1 := errors.New("1. response error") 214 tm := martiantest.NewModifier() 215 tm.ResponseError(reserr1) 216 fg.AddResponseModifier(tm) 217 218 tm2 := martiantest.NewModifier() 219 reserr2 := errors.New("2. response error") 220 tm2.ResponseError(reserr2) 221 fg.AddResponseModifier(tm2) 222 223 req, err := http.NewRequest("GET", "http://example.com/", nil) 224 if err != nil { 225 t.Fatalf("http.NewRequest(): got %v, want no error", err) 226 } 227 _, remove, err := martian.TestContext(req, nil, nil) 228 if err != nil { 229 t.Fatalf("TestContext(): got %v, want no error", err) 230 } 231 defer remove() 232 233 res := proxyutil.NewResponse(200, nil, req) 234 235 merr := martian.NewMultiError() 236 merr.Add(reserr1) 237 merr.Add(reserr2) 238 239 if err := fg.ModifyResponse(res); err == nil { 240 t.Fatalf("fg.ModifyResponse(): got %v, want %v", err, merr) 241 } 242 243 if err := fg.ModifyResponse(res); err.Error() != merr.Error() { 244 t.Fatalf("fg.ModifyResponse(): got %v, want %v", err, merr) 245 } 246 } 247 248 func TestVerifyRequests(t *testing.T) { 249 fg := NewGroup() 250 251 if err := fg.VerifyRequests(); err != nil { 252 t.Fatalf("VerifyRequest(): got %v, want no error", err) 253 } 254 255 errs := []error{} 256 for i := 0; i < 3; i++ { 257 err := fmt.Errorf("%d. verify request failure", i) 258 259 tv := &verify.TestVerifier{ 260 RequestError: err, 261 } 262 fg.AddRequestModifier(tv) 263 264 errs = append(errs, err) 265 } 266 267 merr, ok := fg.VerifyRequests().(*martian.MultiError) 268 if !ok { 269 t.Fatal("VerifyRequests(): got nil, want *verify.MultiError") 270 } 271 272 if !reflect.DeepEqual(merr.Errors(), errs) { 273 t.Errorf("merr.Errors(): got %v, want %v", merr.Errors(), errs) 274 } 275 } 276 277 func TestVerifyResponses(t *testing.T) { 278 fg := NewGroup() 279 280 if err := fg.VerifyResponses(); err != nil { 281 t.Fatalf("VerifyResponses(): got %v, want no error", err) 282 } 283 284 errs := []error{} 285 for i := 0; i < 3; i++ { 286 err := fmt.Errorf("%d. verify responses failure", i) 287 288 tv := &verify.TestVerifier{ 289 ResponseError: err, 290 } 291 fg.AddResponseModifier(tv) 292 293 errs = append(errs, err) 294 } 295 296 merr, ok := fg.VerifyResponses().(*martian.MultiError) 297 if !ok { 298 t.Fatal("VerifyResponses(): got nil, want *verify.MultiError") 299 } 300 301 if !reflect.DeepEqual(merr.Errors(), errs) { 302 t.Errorf("merr.Errors(): got %v, want %v", merr.Errors(), errs) 303 } 304 } 305 306 func TestResets(t *testing.T) { 307 fg := NewGroup() 308 309 for i := 0; i < 3; i++ { 310 tv := &verify.TestVerifier{ 311 RequestError: fmt.Errorf("%d. verify request error", i), 312 ResponseError: fmt.Errorf("%d. verify response error", i), 313 } 314 fg.AddRequestModifier(tv) 315 fg.AddResponseModifier(tv) 316 } 317 318 if err := fg.VerifyRequests(); err == nil { 319 t.Fatal("VerifyRequests(): got nil, want error") 320 } 321 if err := fg.VerifyResponses(); err == nil { 322 t.Fatal("VerifyResponses(): got nil, want error") 323 } 324 325 fg.ResetRequestVerifications() 326 fg.ResetResponseVerifications() 327 328 if err := fg.VerifyRequests(); err != nil { 329 t.Errorf("VerifyRequests(): got %v, want no error", err) 330 } 331 if err := fg.VerifyResponses(); err != nil { 332 t.Errorf("VerifyResponses(): got %v, want no error", err) 333 } 334 }