github.com/dcarley/cf-cli@v6.24.1-0.20170220111324-4225ff346898+incompatible/api/cloudcontroller/wrapper/wrapperfakes/fake_request_logger_output.go (about) 1 // This file was generated by counterfeiter 2 package wrapperfakes 3 4 import ( 5 "sync" 6 "time" 7 8 "code.cloudfoundry.org/cli/api/cloudcontroller/wrapper" 9 ) 10 11 type FakeRequestLoggerOutput struct { 12 DisplayJSONBodyStub func(body []byte) error 13 displayJSONBodyMutex sync.RWMutex 14 displayJSONBodyArgsForCall []struct { 15 body []byte 16 } 17 displayJSONBodyReturns struct { 18 result1 error 19 } 20 DisplayHeaderStub func(name string, value string) error 21 displayHeaderMutex sync.RWMutex 22 displayHeaderArgsForCall []struct { 23 name string 24 value string 25 } 26 displayHeaderReturns struct { 27 result1 error 28 } 29 DisplayHostStub func(name string) error 30 displayHostMutex sync.RWMutex 31 displayHostArgsForCall []struct { 32 name string 33 } 34 displayHostReturns struct { 35 result1 error 36 } 37 DisplayRequestHeaderStub func(method string, uri string, httpProtocol string) error 38 displayRequestHeaderMutex sync.RWMutex 39 displayRequestHeaderArgsForCall []struct { 40 method string 41 uri string 42 httpProtocol string 43 } 44 displayRequestHeaderReturns struct { 45 result1 error 46 } 47 DisplayResponseHeaderStub func(httpProtocol string, status string) error 48 displayResponseHeaderMutex sync.RWMutex 49 displayResponseHeaderArgsForCall []struct { 50 httpProtocol string 51 status string 52 } 53 displayResponseHeaderReturns struct { 54 result1 error 55 } 56 DisplayTypeStub func(name string, requestDate time.Time) error 57 displayTypeMutex sync.RWMutex 58 displayTypeArgsForCall []struct { 59 name string 60 requestDate time.Time 61 } 62 displayTypeReturns struct { 63 result1 error 64 } 65 HandleInternalErrorStub func(err error) 66 handleInternalErrorMutex sync.RWMutex 67 handleInternalErrorArgsForCall []struct { 68 err error 69 } 70 StartStub func() error 71 startMutex sync.RWMutex 72 startArgsForCall []struct{} 73 startReturns struct { 74 result1 error 75 } 76 StopStub func() error 77 stopMutex sync.RWMutex 78 stopArgsForCall []struct{} 79 stopReturns struct { 80 result1 error 81 } 82 invocations map[string][][]interface{} 83 invocationsMutex sync.RWMutex 84 } 85 86 func (fake *FakeRequestLoggerOutput) DisplayJSONBody(body []byte) error { 87 var bodyCopy []byte 88 if body != nil { 89 bodyCopy = make([]byte, len(body)) 90 copy(bodyCopy, body) 91 } 92 fake.displayJSONBodyMutex.Lock() 93 fake.displayJSONBodyArgsForCall = append(fake.displayJSONBodyArgsForCall, struct { 94 body []byte 95 }{bodyCopy}) 96 fake.recordInvocation("DisplayJSONBody", []interface{}{bodyCopy}) 97 fake.displayJSONBodyMutex.Unlock() 98 if fake.DisplayJSONBodyStub != nil { 99 return fake.DisplayJSONBodyStub(body) 100 } else { 101 return fake.displayJSONBodyReturns.result1 102 } 103 } 104 105 func (fake *FakeRequestLoggerOutput) DisplayJSONBodyCallCount() int { 106 fake.displayJSONBodyMutex.RLock() 107 defer fake.displayJSONBodyMutex.RUnlock() 108 return len(fake.displayJSONBodyArgsForCall) 109 } 110 111 func (fake *FakeRequestLoggerOutput) DisplayJSONBodyArgsForCall(i int) []byte { 112 fake.displayJSONBodyMutex.RLock() 113 defer fake.displayJSONBodyMutex.RUnlock() 114 return fake.displayJSONBodyArgsForCall[i].body 115 } 116 117 func (fake *FakeRequestLoggerOutput) DisplayJSONBodyReturns(result1 error) { 118 fake.DisplayJSONBodyStub = nil 119 fake.displayJSONBodyReturns = struct { 120 result1 error 121 }{result1} 122 } 123 124 func (fake *FakeRequestLoggerOutput) DisplayHeader(name string, value string) error { 125 fake.displayHeaderMutex.Lock() 126 fake.displayHeaderArgsForCall = append(fake.displayHeaderArgsForCall, struct { 127 name string 128 value string 129 }{name, value}) 130 fake.recordInvocation("DisplayHeader", []interface{}{name, value}) 131 fake.displayHeaderMutex.Unlock() 132 if fake.DisplayHeaderStub != nil { 133 return fake.DisplayHeaderStub(name, value) 134 } else { 135 return fake.displayHeaderReturns.result1 136 } 137 } 138 139 func (fake *FakeRequestLoggerOutput) DisplayHeaderCallCount() int { 140 fake.displayHeaderMutex.RLock() 141 defer fake.displayHeaderMutex.RUnlock() 142 return len(fake.displayHeaderArgsForCall) 143 } 144 145 func (fake *FakeRequestLoggerOutput) DisplayHeaderArgsForCall(i int) (string, string) { 146 fake.displayHeaderMutex.RLock() 147 defer fake.displayHeaderMutex.RUnlock() 148 return fake.displayHeaderArgsForCall[i].name, fake.displayHeaderArgsForCall[i].value 149 } 150 151 func (fake *FakeRequestLoggerOutput) DisplayHeaderReturns(result1 error) { 152 fake.DisplayHeaderStub = nil 153 fake.displayHeaderReturns = struct { 154 result1 error 155 }{result1} 156 } 157 158 func (fake *FakeRequestLoggerOutput) DisplayHost(name string) error { 159 fake.displayHostMutex.Lock() 160 fake.displayHostArgsForCall = append(fake.displayHostArgsForCall, struct { 161 name string 162 }{name}) 163 fake.recordInvocation("DisplayHost", []interface{}{name}) 164 fake.displayHostMutex.Unlock() 165 if fake.DisplayHostStub != nil { 166 return fake.DisplayHostStub(name) 167 } else { 168 return fake.displayHostReturns.result1 169 } 170 } 171 172 func (fake *FakeRequestLoggerOutput) DisplayHostCallCount() int { 173 fake.displayHostMutex.RLock() 174 defer fake.displayHostMutex.RUnlock() 175 return len(fake.displayHostArgsForCall) 176 } 177 178 func (fake *FakeRequestLoggerOutput) DisplayHostArgsForCall(i int) string { 179 fake.displayHostMutex.RLock() 180 defer fake.displayHostMutex.RUnlock() 181 return fake.displayHostArgsForCall[i].name 182 } 183 184 func (fake *FakeRequestLoggerOutput) DisplayHostReturns(result1 error) { 185 fake.DisplayHostStub = nil 186 fake.displayHostReturns = struct { 187 result1 error 188 }{result1} 189 } 190 191 func (fake *FakeRequestLoggerOutput) DisplayRequestHeader(method string, uri string, httpProtocol string) error { 192 fake.displayRequestHeaderMutex.Lock() 193 fake.displayRequestHeaderArgsForCall = append(fake.displayRequestHeaderArgsForCall, struct { 194 method string 195 uri string 196 httpProtocol string 197 }{method, uri, httpProtocol}) 198 fake.recordInvocation("DisplayRequestHeader", []interface{}{method, uri, httpProtocol}) 199 fake.displayRequestHeaderMutex.Unlock() 200 if fake.DisplayRequestHeaderStub != nil { 201 return fake.DisplayRequestHeaderStub(method, uri, httpProtocol) 202 } else { 203 return fake.displayRequestHeaderReturns.result1 204 } 205 } 206 207 func (fake *FakeRequestLoggerOutput) DisplayRequestHeaderCallCount() int { 208 fake.displayRequestHeaderMutex.RLock() 209 defer fake.displayRequestHeaderMutex.RUnlock() 210 return len(fake.displayRequestHeaderArgsForCall) 211 } 212 213 func (fake *FakeRequestLoggerOutput) DisplayRequestHeaderArgsForCall(i int) (string, string, string) { 214 fake.displayRequestHeaderMutex.RLock() 215 defer fake.displayRequestHeaderMutex.RUnlock() 216 return fake.displayRequestHeaderArgsForCall[i].method, fake.displayRequestHeaderArgsForCall[i].uri, fake.displayRequestHeaderArgsForCall[i].httpProtocol 217 } 218 219 func (fake *FakeRequestLoggerOutput) DisplayRequestHeaderReturns(result1 error) { 220 fake.DisplayRequestHeaderStub = nil 221 fake.displayRequestHeaderReturns = struct { 222 result1 error 223 }{result1} 224 } 225 226 func (fake *FakeRequestLoggerOutput) DisplayResponseHeader(httpProtocol string, status string) error { 227 fake.displayResponseHeaderMutex.Lock() 228 fake.displayResponseHeaderArgsForCall = append(fake.displayResponseHeaderArgsForCall, struct { 229 httpProtocol string 230 status string 231 }{httpProtocol, status}) 232 fake.recordInvocation("DisplayResponseHeader", []interface{}{httpProtocol, status}) 233 fake.displayResponseHeaderMutex.Unlock() 234 if fake.DisplayResponseHeaderStub != nil { 235 return fake.DisplayResponseHeaderStub(httpProtocol, status) 236 } else { 237 return fake.displayResponseHeaderReturns.result1 238 } 239 } 240 241 func (fake *FakeRequestLoggerOutput) DisplayResponseHeaderCallCount() int { 242 fake.displayResponseHeaderMutex.RLock() 243 defer fake.displayResponseHeaderMutex.RUnlock() 244 return len(fake.displayResponseHeaderArgsForCall) 245 } 246 247 func (fake *FakeRequestLoggerOutput) DisplayResponseHeaderArgsForCall(i int) (string, string) { 248 fake.displayResponseHeaderMutex.RLock() 249 defer fake.displayResponseHeaderMutex.RUnlock() 250 return fake.displayResponseHeaderArgsForCall[i].httpProtocol, fake.displayResponseHeaderArgsForCall[i].status 251 } 252 253 func (fake *FakeRequestLoggerOutput) DisplayResponseHeaderReturns(result1 error) { 254 fake.DisplayResponseHeaderStub = nil 255 fake.displayResponseHeaderReturns = struct { 256 result1 error 257 }{result1} 258 } 259 260 func (fake *FakeRequestLoggerOutput) DisplayType(name string, requestDate time.Time) error { 261 fake.displayTypeMutex.Lock() 262 fake.displayTypeArgsForCall = append(fake.displayTypeArgsForCall, struct { 263 name string 264 requestDate time.Time 265 }{name, requestDate}) 266 fake.recordInvocation("DisplayType", []interface{}{name, requestDate}) 267 fake.displayTypeMutex.Unlock() 268 if fake.DisplayTypeStub != nil { 269 return fake.DisplayTypeStub(name, requestDate) 270 } else { 271 return fake.displayTypeReturns.result1 272 } 273 } 274 275 func (fake *FakeRequestLoggerOutput) DisplayTypeCallCount() int { 276 fake.displayTypeMutex.RLock() 277 defer fake.displayTypeMutex.RUnlock() 278 return len(fake.displayTypeArgsForCall) 279 } 280 281 func (fake *FakeRequestLoggerOutput) DisplayTypeArgsForCall(i int) (string, time.Time) { 282 fake.displayTypeMutex.RLock() 283 defer fake.displayTypeMutex.RUnlock() 284 return fake.displayTypeArgsForCall[i].name, fake.displayTypeArgsForCall[i].requestDate 285 } 286 287 func (fake *FakeRequestLoggerOutput) DisplayTypeReturns(result1 error) { 288 fake.DisplayTypeStub = nil 289 fake.displayTypeReturns = struct { 290 result1 error 291 }{result1} 292 } 293 294 func (fake *FakeRequestLoggerOutput) HandleInternalError(err error) { 295 fake.handleInternalErrorMutex.Lock() 296 fake.handleInternalErrorArgsForCall = append(fake.handleInternalErrorArgsForCall, struct { 297 err error 298 }{err}) 299 fake.recordInvocation("HandleInternalError", []interface{}{err}) 300 fake.handleInternalErrorMutex.Unlock() 301 if fake.HandleInternalErrorStub != nil { 302 fake.HandleInternalErrorStub(err) 303 } 304 } 305 306 func (fake *FakeRequestLoggerOutput) HandleInternalErrorCallCount() int { 307 fake.handleInternalErrorMutex.RLock() 308 defer fake.handleInternalErrorMutex.RUnlock() 309 return len(fake.handleInternalErrorArgsForCall) 310 } 311 312 func (fake *FakeRequestLoggerOutput) HandleInternalErrorArgsForCall(i int) error { 313 fake.handleInternalErrorMutex.RLock() 314 defer fake.handleInternalErrorMutex.RUnlock() 315 return fake.handleInternalErrorArgsForCall[i].err 316 } 317 318 func (fake *FakeRequestLoggerOutput) Start() error { 319 fake.startMutex.Lock() 320 fake.startArgsForCall = append(fake.startArgsForCall, struct{}{}) 321 fake.recordInvocation("Start", []interface{}{}) 322 fake.startMutex.Unlock() 323 if fake.StartStub != nil { 324 return fake.StartStub() 325 } else { 326 return fake.startReturns.result1 327 } 328 } 329 330 func (fake *FakeRequestLoggerOutput) StartCallCount() int { 331 fake.startMutex.RLock() 332 defer fake.startMutex.RUnlock() 333 return len(fake.startArgsForCall) 334 } 335 336 func (fake *FakeRequestLoggerOutput) StartReturns(result1 error) { 337 fake.StartStub = nil 338 fake.startReturns = struct { 339 result1 error 340 }{result1} 341 } 342 343 func (fake *FakeRequestLoggerOutput) Stop() error { 344 fake.stopMutex.Lock() 345 fake.stopArgsForCall = append(fake.stopArgsForCall, struct{}{}) 346 fake.recordInvocation("Stop", []interface{}{}) 347 fake.stopMutex.Unlock() 348 if fake.StopStub != nil { 349 return fake.StopStub() 350 } else { 351 return fake.stopReturns.result1 352 } 353 } 354 355 func (fake *FakeRequestLoggerOutput) StopCallCount() int { 356 fake.stopMutex.RLock() 357 defer fake.stopMutex.RUnlock() 358 return len(fake.stopArgsForCall) 359 } 360 361 func (fake *FakeRequestLoggerOutput) StopReturns(result1 error) { 362 fake.StopStub = nil 363 fake.stopReturns = struct { 364 result1 error 365 }{result1} 366 } 367 368 func (fake *FakeRequestLoggerOutput) Invocations() map[string][][]interface{} { 369 fake.invocationsMutex.RLock() 370 defer fake.invocationsMutex.RUnlock() 371 fake.displayJSONBodyMutex.RLock() 372 defer fake.displayJSONBodyMutex.RUnlock() 373 fake.displayHeaderMutex.RLock() 374 defer fake.displayHeaderMutex.RUnlock() 375 fake.displayHostMutex.RLock() 376 defer fake.displayHostMutex.RUnlock() 377 fake.displayRequestHeaderMutex.RLock() 378 defer fake.displayRequestHeaderMutex.RUnlock() 379 fake.displayResponseHeaderMutex.RLock() 380 defer fake.displayResponseHeaderMutex.RUnlock() 381 fake.displayTypeMutex.RLock() 382 defer fake.displayTypeMutex.RUnlock() 383 fake.handleInternalErrorMutex.RLock() 384 defer fake.handleInternalErrorMutex.RUnlock() 385 fake.startMutex.RLock() 386 defer fake.startMutex.RUnlock() 387 fake.stopMutex.RLock() 388 defer fake.stopMutex.RUnlock() 389 return fake.invocations 390 } 391 392 func (fake *FakeRequestLoggerOutput) recordInvocation(key string, args []interface{}) { 393 fake.invocationsMutex.Lock() 394 defer fake.invocationsMutex.Unlock() 395 if fake.invocations == nil { 396 fake.invocations = map[string][][]interface{}{} 397 } 398 if fake.invocations[key] == nil { 399 fake.invocations[key] = [][]interface{}{} 400 } 401 fake.invocations[key] = append(fake.invocations[key], args) 402 } 403 404 var _ wrapper.RequestLoggerOutput = new(FakeRequestLoggerOutput)