github.com/google/martian/v3@v3.3.3/header/header_filter_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 header 16 17 import ( 18 "net/http" 19 "testing" 20 21 "github.com/google/martian/v3/filter" 22 "github.com/google/martian/v3/martiantest" 23 "github.com/google/martian/v3/parse" 24 "github.com/google/martian/v3/proxyutil" 25 ) 26 27 func TestFilterFromJSON(t *testing.T) { 28 msg := []byte(`{ 29 "header.Filter": { 30 "scope": ["request", "response"], 31 "name": "Martian-Passthrough", 32 "value": "true", 33 "modifier": { 34 "header.Modifier" : { 35 "scope": ["request", "response"], 36 "name": "Martian-Testing", 37 "value": "true" 38 } 39 }, 40 "else": { 41 "header.Modifier" : { 42 "scope": ["request", "response"], 43 "name": "Martian-Testing", 44 "value": "false" 45 } 46 } 47 } 48 }`) 49 50 r, err := parse.FromJSON(msg) 51 if err != nil { 52 t.Fatalf("parse.FromJSON(): got %v, want no error", err) 53 } 54 reqmod := r.RequestModifier() 55 if reqmod == nil { 56 t.Fatal("reqmod: got nil, want not nil") 57 } 58 59 // Matching condition for request 60 req, err := http.NewRequest("GET", "http://example.com", nil) 61 if err != nil { 62 t.Fatalf("http.NewRequest(): got %v, want no error", err) 63 } 64 req.Header.Set("Martian-Passthrough", "true") 65 if err := reqmod.ModifyRequest(req); err != nil { 66 t.Fatalf("ModifyRequest(): got %v, want no error", err) 67 } 68 if got, want := req.Header.Get("Martian-Testing"), "true"; got != want { 69 t.Fatalf("req.Header.Get(%q): got %q, want %q", "Martian-Testing", got, want) 70 } 71 72 // Else condition for request 73 req, err = http.NewRequest("GET", "http://example.com", nil) 74 if err != nil { 75 t.Fatalf("http.NewRequest(): got %v, want no error", err) 76 } 77 req.Header.Set("Martian-Passthrough", "false") 78 if err := reqmod.ModifyRequest(req); err != nil { 79 t.Fatalf("ModifyRequest(): got %v, want no error", err) 80 } 81 if got, want := req.Header.Get("Martian-Testing"), "false"; got != want { 82 t.Fatalf("req.Header.Get(%q): got %q, want %q", "Martian-Testing", got, want) 83 } 84 85 // Matching condition for response 86 resmod := r.ResponseModifier() 87 if resmod == nil { 88 t.Fatal("resmod: got nil, want not nil") 89 } 90 91 res := proxyutil.NewResponse(200, nil, req) 92 res.Header.Set("Martian-Passthrough", "true") 93 if err := resmod.ModifyResponse(res); err != nil { 94 t.Fatalf("ModifyResponse(): got %v, want no error", err) 95 } 96 if got, want := res.Header.Get("Martian-Testing"), "true"; got != want { 97 t.Fatalf("res.Header.Get(%q): got %q, want %q", "Martian-Testing", got, want) 98 } 99 100 // Else condition for response 101 resmod = r.ResponseModifier() 102 if resmod == nil { 103 t.Fatal("resmod: got nil, want not nil") 104 } 105 106 res = proxyutil.NewResponse(200, nil, req) 107 res.Header.Set("Martian-Passthrough", "false") 108 if err := resmod.ModifyResponse(res); err != nil { 109 t.Fatalf("ModifyResponse(): got %v, want no error", err) 110 } 111 if got, want := res.Header.Get("Martian-Testing"), "false"; got != want { 112 t.Fatalf("res.Header.Get(%q): got %q, want %q", "Martian-Testing", got, want) 113 } 114 } 115 116 func TestFilterFromJSONWithoutElse(t *testing.T) { 117 msg := []byte(`{ 118 "header.Filter": { 119 "scope": ["request", "response"], 120 "name": "Martian-Passthrough", 121 "value": "true", 122 "modifier": { 123 "header.Modifier" : { 124 "scope": ["request", "response"], 125 "name": "Martian-Testing", 126 "value": "true" 127 } 128 } 129 } 130 }`) 131 _, err := parse.FromJSON(msg) 132 if err != nil { 133 t.Fatalf("parse.FromJSON(): got %v, want no error", err) 134 } 135 } 136 137 func TestRequestWhenTrueCondition(t *testing.T) { 138 hm := NewMatcher("Martian-Testing", "true") 139 140 tt := []struct { 141 name string 142 values []string 143 want bool 144 }{ 145 { 146 name: "Martian-Production", 147 values: []string{"true"}, 148 want: false, 149 }, 150 { 151 name: "Martian-Testing", 152 values: []string{"see-next-value", "true"}, 153 want: true, 154 }, 155 } 156 157 for i, tc := range tt { 158 tm := martiantest.NewModifier() 159 160 f := filter.New() 161 f.SetRequestCondition(hm) 162 f.RequestWhenTrue(tm) 163 164 req, err := http.NewRequest("GET", "/", nil) 165 if err != nil { 166 t.Fatalf("http.NewRequest(): got %v, want no error", err) 167 } 168 169 req.Header[tc.name] = tc.values 170 171 if err := f.ModifyRequest(req); err != nil { 172 t.Fatalf("%d. ModifyRequest(): got %v, want no error", i, err) 173 } 174 175 if tm.RequestModified() != tc.want { 176 t.Errorf("%d. tm.RequestModified(): got %t, want %t", i, tm.RequestModified(), tc.want) 177 } 178 } 179 } 180 181 func TestRequestWhenFalse(t *testing.T) { 182 hm := NewMatcher("Martian-Testing", "true") 183 tt := []struct { 184 name string 185 values []string 186 want bool 187 }{ 188 { 189 name: "Martian-Production", 190 values: []string{"true"}, 191 want: true, 192 }, 193 { 194 name: "Martian-Testing", 195 values: []string{"see-next-value", "true"}, 196 want: false, 197 }, 198 } 199 200 for i, tc := range tt { 201 tm := martiantest.NewModifier() 202 203 f := filter.New() 204 f.SetRequestCondition(hm) 205 f.RequestWhenFalse(tm) 206 207 req, err := http.NewRequest("GET", "/", nil) 208 if err != nil { 209 t.Fatalf("http.NewRequest(): got %v, want no error", err) 210 } 211 212 req.Header[tc.name] = tc.values 213 214 if err := f.ModifyRequest(req); err != nil { 215 t.Fatalf("%d. ModifyRequest(): got %v, want no error", i, err) 216 } 217 218 if tm.RequestModified() != tc.want { 219 t.Errorf("%d. tm.RequestModified(): got %t, want %t", i, tm.RequestModified(), tc.want) 220 } 221 } 222 } 223 224 func TestResponseWhenTrue(t *testing.T) { 225 hm := NewMatcher("Martian-Testing", "true") 226 227 tt := []struct { 228 name string 229 values []string 230 want bool 231 }{ 232 { 233 name: "Martian-Production", 234 values: []string{"true"}, 235 want: false, 236 }, 237 { 238 name: "Martian-Testing", 239 values: []string{"see-next-value", "true"}, 240 want: true, 241 }, 242 } 243 244 for i, tc := range tt { 245 tm := martiantest.NewModifier() 246 247 f := filter.New() 248 f.SetResponseCondition(hm) 249 f.ResponseWhenTrue(tm) 250 251 req, err := http.NewRequest("GET", "/", nil) 252 if err != nil { 253 t.Fatalf("http.NewRequest(): got %v, want no error", err) 254 } 255 256 res := proxyutil.NewResponse(200, nil, req) 257 258 res.Header[tc.name] = tc.values 259 260 if err := f.ModifyResponse(res); err != nil { 261 t.Fatalf("%d. ModifyResponse(): got %v, want no error", i, err) 262 } 263 264 if tm.ResponseModified() != tc.want { 265 t.Errorf("%d. tm.ResponseModified(): got %t, want %t", i, tm.RequestModified(), tc.want) 266 } 267 } 268 } 269 270 func TestResponseWhenFalse(t *testing.T) { 271 hm := NewMatcher("Martian-Testing", "true") 272 273 tt := []struct { 274 name string 275 values []string 276 want bool 277 }{ 278 { 279 name: "Martian-Production", 280 values: []string{"true"}, 281 want: true, 282 }, 283 { 284 name: "Martian-Testing", 285 values: []string{"see-next-value", "true"}, 286 want: false, 287 }, 288 } 289 290 for i, tc := range tt { 291 tm := martiantest.NewModifier() 292 293 f := filter.New() 294 f.SetResponseCondition(hm) 295 f.ResponseWhenFalse(tm) 296 297 req, err := http.NewRequest("GET", "/", nil) 298 if err != nil { 299 t.Fatalf("http.NewRequest(): got %v, want no error", err) 300 } 301 res := proxyutil.NewResponse(200, nil, req) 302 303 res.Header[tc.name] = tc.values 304 305 if err := f.ModifyResponse(res); err != nil { 306 t.Fatalf("%d. ModifyResponse(): got %v, want no error", i, err) 307 } 308 309 if tm.ResponseModified() != tc.want { 310 t.Errorf("%d. tm.ResponseModified(): got %t, want %t", i, tm.RequestModified(), tc.want) 311 } 312 } 313 }