github.com/wata727/tflint@v0.12.2-0.20191013070026-96dd0d36f385/client/aws_elbv2_mock.go (about) 1 // Code generated by MockGen. DO NOT EDIT. 2 // Source: ../vendor/github.com/aws/aws-sdk-go/service/elbv2/elbv2iface/interface.go 3 4 // Package client is a generated GoMock package. 5 package client 6 7 import ( 8 aws "github.com/aws/aws-sdk-go/aws" 9 request "github.com/aws/aws-sdk-go/aws/request" 10 elbv2 "github.com/aws/aws-sdk-go/service/elbv2" 11 gomock "github.com/golang/mock/gomock" 12 reflect "reflect" 13 ) 14 15 // MockELBV2API is a mock of ELBV2API interface 16 type MockELBV2API struct { 17 ctrl *gomock.Controller 18 recorder *MockELBV2APIMockRecorder 19 } 20 21 // MockELBV2APIMockRecorder is the mock recorder for MockELBV2API 22 type MockELBV2APIMockRecorder struct { 23 mock *MockELBV2API 24 } 25 26 // NewMockELBV2API creates a new mock instance 27 func NewMockELBV2API(ctrl *gomock.Controller) *MockELBV2API { 28 mock := &MockELBV2API{ctrl: ctrl} 29 mock.recorder = &MockELBV2APIMockRecorder{mock} 30 return mock 31 } 32 33 // EXPECT returns an object that allows the caller to indicate expected use 34 func (m *MockELBV2API) EXPECT() *MockELBV2APIMockRecorder { 35 return m.recorder 36 } 37 38 // AddListenerCertificates mocks base method 39 func (m *MockELBV2API) AddListenerCertificates(arg0 *elbv2.AddListenerCertificatesInput) (*elbv2.AddListenerCertificatesOutput, error) { 40 m.ctrl.T.Helper() 41 ret := m.ctrl.Call(m, "AddListenerCertificates", arg0) 42 ret0, _ := ret[0].(*elbv2.AddListenerCertificatesOutput) 43 ret1, _ := ret[1].(error) 44 return ret0, ret1 45 } 46 47 // AddListenerCertificates indicates an expected call of AddListenerCertificates 48 func (mr *MockELBV2APIMockRecorder) AddListenerCertificates(arg0 interface{}) *gomock.Call { 49 mr.mock.ctrl.T.Helper() 50 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddListenerCertificates", reflect.TypeOf((*MockELBV2API)(nil).AddListenerCertificates), arg0) 51 } 52 53 // AddListenerCertificatesWithContext mocks base method 54 func (m *MockELBV2API) AddListenerCertificatesWithContext(arg0 aws.Context, arg1 *elbv2.AddListenerCertificatesInput, arg2 ...request.Option) (*elbv2.AddListenerCertificatesOutput, error) { 55 m.ctrl.T.Helper() 56 varargs := []interface{}{arg0, arg1} 57 for _, a := range arg2 { 58 varargs = append(varargs, a) 59 } 60 ret := m.ctrl.Call(m, "AddListenerCertificatesWithContext", varargs...) 61 ret0, _ := ret[0].(*elbv2.AddListenerCertificatesOutput) 62 ret1, _ := ret[1].(error) 63 return ret0, ret1 64 } 65 66 // AddListenerCertificatesWithContext indicates an expected call of AddListenerCertificatesWithContext 67 func (mr *MockELBV2APIMockRecorder) AddListenerCertificatesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 68 mr.mock.ctrl.T.Helper() 69 varargs := append([]interface{}{arg0, arg1}, arg2...) 70 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddListenerCertificatesWithContext", reflect.TypeOf((*MockELBV2API)(nil).AddListenerCertificatesWithContext), varargs...) 71 } 72 73 // AddListenerCertificatesRequest mocks base method 74 func (m *MockELBV2API) AddListenerCertificatesRequest(arg0 *elbv2.AddListenerCertificatesInput) (*request.Request, *elbv2.AddListenerCertificatesOutput) { 75 m.ctrl.T.Helper() 76 ret := m.ctrl.Call(m, "AddListenerCertificatesRequest", arg0) 77 ret0, _ := ret[0].(*request.Request) 78 ret1, _ := ret[1].(*elbv2.AddListenerCertificatesOutput) 79 return ret0, ret1 80 } 81 82 // AddListenerCertificatesRequest indicates an expected call of AddListenerCertificatesRequest 83 func (mr *MockELBV2APIMockRecorder) AddListenerCertificatesRequest(arg0 interface{}) *gomock.Call { 84 mr.mock.ctrl.T.Helper() 85 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddListenerCertificatesRequest", reflect.TypeOf((*MockELBV2API)(nil).AddListenerCertificatesRequest), arg0) 86 } 87 88 // AddTags mocks base method 89 func (m *MockELBV2API) AddTags(arg0 *elbv2.AddTagsInput) (*elbv2.AddTagsOutput, error) { 90 m.ctrl.T.Helper() 91 ret := m.ctrl.Call(m, "AddTags", arg0) 92 ret0, _ := ret[0].(*elbv2.AddTagsOutput) 93 ret1, _ := ret[1].(error) 94 return ret0, ret1 95 } 96 97 // AddTags indicates an expected call of AddTags 98 func (mr *MockELBV2APIMockRecorder) AddTags(arg0 interface{}) *gomock.Call { 99 mr.mock.ctrl.T.Helper() 100 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTags", reflect.TypeOf((*MockELBV2API)(nil).AddTags), arg0) 101 } 102 103 // AddTagsWithContext mocks base method 104 func (m *MockELBV2API) AddTagsWithContext(arg0 aws.Context, arg1 *elbv2.AddTagsInput, arg2 ...request.Option) (*elbv2.AddTagsOutput, error) { 105 m.ctrl.T.Helper() 106 varargs := []interface{}{arg0, arg1} 107 for _, a := range arg2 { 108 varargs = append(varargs, a) 109 } 110 ret := m.ctrl.Call(m, "AddTagsWithContext", varargs...) 111 ret0, _ := ret[0].(*elbv2.AddTagsOutput) 112 ret1, _ := ret[1].(error) 113 return ret0, ret1 114 } 115 116 // AddTagsWithContext indicates an expected call of AddTagsWithContext 117 func (mr *MockELBV2APIMockRecorder) AddTagsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 118 mr.mock.ctrl.T.Helper() 119 varargs := append([]interface{}{arg0, arg1}, arg2...) 120 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTagsWithContext", reflect.TypeOf((*MockELBV2API)(nil).AddTagsWithContext), varargs...) 121 } 122 123 // AddTagsRequest mocks base method 124 func (m *MockELBV2API) AddTagsRequest(arg0 *elbv2.AddTagsInput) (*request.Request, *elbv2.AddTagsOutput) { 125 m.ctrl.T.Helper() 126 ret := m.ctrl.Call(m, "AddTagsRequest", arg0) 127 ret0, _ := ret[0].(*request.Request) 128 ret1, _ := ret[1].(*elbv2.AddTagsOutput) 129 return ret0, ret1 130 } 131 132 // AddTagsRequest indicates an expected call of AddTagsRequest 133 func (mr *MockELBV2APIMockRecorder) AddTagsRequest(arg0 interface{}) *gomock.Call { 134 mr.mock.ctrl.T.Helper() 135 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTagsRequest", reflect.TypeOf((*MockELBV2API)(nil).AddTagsRequest), arg0) 136 } 137 138 // CreateListener mocks base method 139 func (m *MockELBV2API) CreateListener(arg0 *elbv2.CreateListenerInput) (*elbv2.CreateListenerOutput, error) { 140 m.ctrl.T.Helper() 141 ret := m.ctrl.Call(m, "CreateListener", arg0) 142 ret0, _ := ret[0].(*elbv2.CreateListenerOutput) 143 ret1, _ := ret[1].(error) 144 return ret0, ret1 145 } 146 147 // CreateListener indicates an expected call of CreateListener 148 func (mr *MockELBV2APIMockRecorder) CreateListener(arg0 interface{}) *gomock.Call { 149 mr.mock.ctrl.T.Helper() 150 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateListener", reflect.TypeOf((*MockELBV2API)(nil).CreateListener), arg0) 151 } 152 153 // CreateListenerWithContext mocks base method 154 func (m *MockELBV2API) CreateListenerWithContext(arg0 aws.Context, arg1 *elbv2.CreateListenerInput, arg2 ...request.Option) (*elbv2.CreateListenerOutput, error) { 155 m.ctrl.T.Helper() 156 varargs := []interface{}{arg0, arg1} 157 for _, a := range arg2 { 158 varargs = append(varargs, a) 159 } 160 ret := m.ctrl.Call(m, "CreateListenerWithContext", varargs...) 161 ret0, _ := ret[0].(*elbv2.CreateListenerOutput) 162 ret1, _ := ret[1].(error) 163 return ret0, ret1 164 } 165 166 // CreateListenerWithContext indicates an expected call of CreateListenerWithContext 167 func (mr *MockELBV2APIMockRecorder) CreateListenerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 168 mr.mock.ctrl.T.Helper() 169 varargs := append([]interface{}{arg0, arg1}, arg2...) 170 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateListenerWithContext", reflect.TypeOf((*MockELBV2API)(nil).CreateListenerWithContext), varargs...) 171 } 172 173 // CreateListenerRequest mocks base method 174 func (m *MockELBV2API) CreateListenerRequest(arg0 *elbv2.CreateListenerInput) (*request.Request, *elbv2.CreateListenerOutput) { 175 m.ctrl.T.Helper() 176 ret := m.ctrl.Call(m, "CreateListenerRequest", arg0) 177 ret0, _ := ret[0].(*request.Request) 178 ret1, _ := ret[1].(*elbv2.CreateListenerOutput) 179 return ret0, ret1 180 } 181 182 // CreateListenerRequest indicates an expected call of CreateListenerRequest 183 func (mr *MockELBV2APIMockRecorder) CreateListenerRequest(arg0 interface{}) *gomock.Call { 184 mr.mock.ctrl.T.Helper() 185 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateListenerRequest", reflect.TypeOf((*MockELBV2API)(nil).CreateListenerRequest), arg0) 186 } 187 188 // CreateLoadBalancer mocks base method 189 func (m *MockELBV2API) CreateLoadBalancer(arg0 *elbv2.CreateLoadBalancerInput) (*elbv2.CreateLoadBalancerOutput, error) { 190 m.ctrl.T.Helper() 191 ret := m.ctrl.Call(m, "CreateLoadBalancer", arg0) 192 ret0, _ := ret[0].(*elbv2.CreateLoadBalancerOutput) 193 ret1, _ := ret[1].(error) 194 return ret0, ret1 195 } 196 197 // CreateLoadBalancer indicates an expected call of CreateLoadBalancer 198 func (mr *MockELBV2APIMockRecorder) CreateLoadBalancer(arg0 interface{}) *gomock.Call { 199 mr.mock.ctrl.T.Helper() 200 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoadBalancer", reflect.TypeOf((*MockELBV2API)(nil).CreateLoadBalancer), arg0) 201 } 202 203 // CreateLoadBalancerWithContext mocks base method 204 func (m *MockELBV2API) CreateLoadBalancerWithContext(arg0 aws.Context, arg1 *elbv2.CreateLoadBalancerInput, arg2 ...request.Option) (*elbv2.CreateLoadBalancerOutput, error) { 205 m.ctrl.T.Helper() 206 varargs := []interface{}{arg0, arg1} 207 for _, a := range arg2 { 208 varargs = append(varargs, a) 209 } 210 ret := m.ctrl.Call(m, "CreateLoadBalancerWithContext", varargs...) 211 ret0, _ := ret[0].(*elbv2.CreateLoadBalancerOutput) 212 ret1, _ := ret[1].(error) 213 return ret0, ret1 214 } 215 216 // CreateLoadBalancerWithContext indicates an expected call of CreateLoadBalancerWithContext 217 func (mr *MockELBV2APIMockRecorder) CreateLoadBalancerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 218 mr.mock.ctrl.T.Helper() 219 varargs := append([]interface{}{arg0, arg1}, arg2...) 220 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoadBalancerWithContext", reflect.TypeOf((*MockELBV2API)(nil).CreateLoadBalancerWithContext), varargs...) 221 } 222 223 // CreateLoadBalancerRequest mocks base method 224 func (m *MockELBV2API) CreateLoadBalancerRequest(arg0 *elbv2.CreateLoadBalancerInput) (*request.Request, *elbv2.CreateLoadBalancerOutput) { 225 m.ctrl.T.Helper() 226 ret := m.ctrl.Call(m, "CreateLoadBalancerRequest", arg0) 227 ret0, _ := ret[0].(*request.Request) 228 ret1, _ := ret[1].(*elbv2.CreateLoadBalancerOutput) 229 return ret0, ret1 230 } 231 232 // CreateLoadBalancerRequest indicates an expected call of CreateLoadBalancerRequest 233 func (mr *MockELBV2APIMockRecorder) CreateLoadBalancerRequest(arg0 interface{}) *gomock.Call { 234 mr.mock.ctrl.T.Helper() 235 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoadBalancerRequest", reflect.TypeOf((*MockELBV2API)(nil).CreateLoadBalancerRequest), arg0) 236 } 237 238 // CreateRule mocks base method 239 func (m *MockELBV2API) CreateRule(arg0 *elbv2.CreateRuleInput) (*elbv2.CreateRuleOutput, error) { 240 m.ctrl.T.Helper() 241 ret := m.ctrl.Call(m, "CreateRule", arg0) 242 ret0, _ := ret[0].(*elbv2.CreateRuleOutput) 243 ret1, _ := ret[1].(error) 244 return ret0, ret1 245 } 246 247 // CreateRule indicates an expected call of CreateRule 248 func (mr *MockELBV2APIMockRecorder) CreateRule(arg0 interface{}) *gomock.Call { 249 mr.mock.ctrl.T.Helper() 250 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRule", reflect.TypeOf((*MockELBV2API)(nil).CreateRule), arg0) 251 } 252 253 // CreateRuleWithContext mocks base method 254 func (m *MockELBV2API) CreateRuleWithContext(arg0 aws.Context, arg1 *elbv2.CreateRuleInput, arg2 ...request.Option) (*elbv2.CreateRuleOutput, error) { 255 m.ctrl.T.Helper() 256 varargs := []interface{}{arg0, arg1} 257 for _, a := range arg2 { 258 varargs = append(varargs, a) 259 } 260 ret := m.ctrl.Call(m, "CreateRuleWithContext", varargs...) 261 ret0, _ := ret[0].(*elbv2.CreateRuleOutput) 262 ret1, _ := ret[1].(error) 263 return ret0, ret1 264 } 265 266 // CreateRuleWithContext indicates an expected call of CreateRuleWithContext 267 func (mr *MockELBV2APIMockRecorder) CreateRuleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 268 mr.mock.ctrl.T.Helper() 269 varargs := append([]interface{}{arg0, arg1}, arg2...) 270 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRuleWithContext", reflect.TypeOf((*MockELBV2API)(nil).CreateRuleWithContext), varargs...) 271 } 272 273 // CreateRuleRequest mocks base method 274 func (m *MockELBV2API) CreateRuleRequest(arg0 *elbv2.CreateRuleInput) (*request.Request, *elbv2.CreateRuleOutput) { 275 m.ctrl.T.Helper() 276 ret := m.ctrl.Call(m, "CreateRuleRequest", arg0) 277 ret0, _ := ret[0].(*request.Request) 278 ret1, _ := ret[1].(*elbv2.CreateRuleOutput) 279 return ret0, ret1 280 } 281 282 // CreateRuleRequest indicates an expected call of CreateRuleRequest 283 func (mr *MockELBV2APIMockRecorder) CreateRuleRequest(arg0 interface{}) *gomock.Call { 284 mr.mock.ctrl.T.Helper() 285 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRuleRequest", reflect.TypeOf((*MockELBV2API)(nil).CreateRuleRequest), arg0) 286 } 287 288 // CreateTargetGroup mocks base method 289 func (m *MockELBV2API) CreateTargetGroup(arg0 *elbv2.CreateTargetGroupInput) (*elbv2.CreateTargetGroupOutput, error) { 290 m.ctrl.T.Helper() 291 ret := m.ctrl.Call(m, "CreateTargetGroup", arg0) 292 ret0, _ := ret[0].(*elbv2.CreateTargetGroupOutput) 293 ret1, _ := ret[1].(error) 294 return ret0, ret1 295 } 296 297 // CreateTargetGroup indicates an expected call of CreateTargetGroup 298 func (mr *MockELBV2APIMockRecorder) CreateTargetGroup(arg0 interface{}) *gomock.Call { 299 mr.mock.ctrl.T.Helper() 300 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTargetGroup", reflect.TypeOf((*MockELBV2API)(nil).CreateTargetGroup), arg0) 301 } 302 303 // CreateTargetGroupWithContext mocks base method 304 func (m *MockELBV2API) CreateTargetGroupWithContext(arg0 aws.Context, arg1 *elbv2.CreateTargetGroupInput, arg2 ...request.Option) (*elbv2.CreateTargetGroupOutput, error) { 305 m.ctrl.T.Helper() 306 varargs := []interface{}{arg0, arg1} 307 for _, a := range arg2 { 308 varargs = append(varargs, a) 309 } 310 ret := m.ctrl.Call(m, "CreateTargetGroupWithContext", varargs...) 311 ret0, _ := ret[0].(*elbv2.CreateTargetGroupOutput) 312 ret1, _ := ret[1].(error) 313 return ret0, ret1 314 } 315 316 // CreateTargetGroupWithContext indicates an expected call of CreateTargetGroupWithContext 317 func (mr *MockELBV2APIMockRecorder) CreateTargetGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 318 mr.mock.ctrl.T.Helper() 319 varargs := append([]interface{}{arg0, arg1}, arg2...) 320 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTargetGroupWithContext", reflect.TypeOf((*MockELBV2API)(nil).CreateTargetGroupWithContext), varargs...) 321 } 322 323 // CreateTargetGroupRequest mocks base method 324 func (m *MockELBV2API) CreateTargetGroupRequest(arg0 *elbv2.CreateTargetGroupInput) (*request.Request, *elbv2.CreateTargetGroupOutput) { 325 m.ctrl.T.Helper() 326 ret := m.ctrl.Call(m, "CreateTargetGroupRequest", arg0) 327 ret0, _ := ret[0].(*request.Request) 328 ret1, _ := ret[1].(*elbv2.CreateTargetGroupOutput) 329 return ret0, ret1 330 } 331 332 // CreateTargetGroupRequest indicates an expected call of CreateTargetGroupRequest 333 func (mr *MockELBV2APIMockRecorder) CreateTargetGroupRequest(arg0 interface{}) *gomock.Call { 334 mr.mock.ctrl.T.Helper() 335 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTargetGroupRequest", reflect.TypeOf((*MockELBV2API)(nil).CreateTargetGroupRequest), arg0) 336 } 337 338 // DeleteListener mocks base method 339 func (m *MockELBV2API) DeleteListener(arg0 *elbv2.DeleteListenerInput) (*elbv2.DeleteListenerOutput, error) { 340 m.ctrl.T.Helper() 341 ret := m.ctrl.Call(m, "DeleteListener", arg0) 342 ret0, _ := ret[0].(*elbv2.DeleteListenerOutput) 343 ret1, _ := ret[1].(error) 344 return ret0, ret1 345 } 346 347 // DeleteListener indicates an expected call of DeleteListener 348 func (mr *MockELBV2APIMockRecorder) DeleteListener(arg0 interface{}) *gomock.Call { 349 mr.mock.ctrl.T.Helper() 350 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteListener", reflect.TypeOf((*MockELBV2API)(nil).DeleteListener), arg0) 351 } 352 353 // DeleteListenerWithContext mocks base method 354 func (m *MockELBV2API) DeleteListenerWithContext(arg0 aws.Context, arg1 *elbv2.DeleteListenerInput, arg2 ...request.Option) (*elbv2.DeleteListenerOutput, error) { 355 m.ctrl.T.Helper() 356 varargs := []interface{}{arg0, arg1} 357 for _, a := range arg2 { 358 varargs = append(varargs, a) 359 } 360 ret := m.ctrl.Call(m, "DeleteListenerWithContext", varargs...) 361 ret0, _ := ret[0].(*elbv2.DeleteListenerOutput) 362 ret1, _ := ret[1].(error) 363 return ret0, ret1 364 } 365 366 // DeleteListenerWithContext indicates an expected call of DeleteListenerWithContext 367 func (mr *MockELBV2APIMockRecorder) DeleteListenerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 368 mr.mock.ctrl.T.Helper() 369 varargs := append([]interface{}{arg0, arg1}, arg2...) 370 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteListenerWithContext", reflect.TypeOf((*MockELBV2API)(nil).DeleteListenerWithContext), varargs...) 371 } 372 373 // DeleteListenerRequest mocks base method 374 func (m *MockELBV2API) DeleteListenerRequest(arg0 *elbv2.DeleteListenerInput) (*request.Request, *elbv2.DeleteListenerOutput) { 375 m.ctrl.T.Helper() 376 ret := m.ctrl.Call(m, "DeleteListenerRequest", arg0) 377 ret0, _ := ret[0].(*request.Request) 378 ret1, _ := ret[1].(*elbv2.DeleteListenerOutput) 379 return ret0, ret1 380 } 381 382 // DeleteListenerRequest indicates an expected call of DeleteListenerRequest 383 func (mr *MockELBV2APIMockRecorder) DeleteListenerRequest(arg0 interface{}) *gomock.Call { 384 mr.mock.ctrl.T.Helper() 385 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteListenerRequest", reflect.TypeOf((*MockELBV2API)(nil).DeleteListenerRequest), arg0) 386 } 387 388 // DeleteLoadBalancer mocks base method 389 func (m *MockELBV2API) DeleteLoadBalancer(arg0 *elbv2.DeleteLoadBalancerInput) (*elbv2.DeleteLoadBalancerOutput, error) { 390 m.ctrl.T.Helper() 391 ret := m.ctrl.Call(m, "DeleteLoadBalancer", arg0) 392 ret0, _ := ret[0].(*elbv2.DeleteLoadBalancerOutput) 393 ret1, _ := ret[1].(error) 394 return ret0, ret1 395 } 396 397 // DeleteLoadBalancer indicates an expected call of DeleteLoadBalancer 398 func (mr *MockELBV2APIMockRecorder) DeleteLoadBalancer(arg0 interface{}) *gomock.Call { 399 mr.mock.ctrl.T.Helper() 400 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancer", reflect.TypeOf((*MockELBV2API)(nil).DeleteLoadBalancer), arg0) 401 } 402 403 // DeleteLoadBalancerWithContext mocks base method 404 func (m *MockELBV2API) DeleteLoadBalancerWithContext(arg0 aws.Context, arg1 *elbv2.DeleteLoadBalancerInput, arg2 ...request.Option) (*elbv2.DeleteLoadBalancerOutput, error) { 405 m.ctrl.T.Helper() 406 varargs := []interface{}{arg0, arg1} 407 for _, a := range arg2 { 408 varargs = append(varargs, a) 409 } 410 ret := m.ctrl.Call(m, "DeleteLoadBalancerWithContext", varargs...) 411 ret0, _ := ret[0].(*elbv2.DeleteLoadBalancerOutput) 412 ret1, _ := ret[1].(error) 413 return ret0, ret1 414 } 415 416 // DeleteLoadBalancerWithContext indicates an expected call of DeleteLoadBalancerWithContext 417 func (mr *MockELBV2APIMockRecorder) DeleteLoadBalancerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 418 mr.mock.ctrl.T.Helper() 419 varargs := append([]interface{}{arg0, arg1}, arg2...) 420 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancerWithContext", reflect.TypeOf((*MockELBV2API)(nil).DeleteLoadBalancerWithContext), varargs...) 421 } 422 423 // DeleteLoadBalancerRequest mocks base method 424 func (m *MockELBV2API) DeleteLoadBalancerRequest(arg0 *elbv2.DeleteLoadBalancerInput) (*request.Request, *elbv2.DeleteLoadBalancerOutput) { 425 m.ctrl.T.Helper() 426 ret := m.ctrl.Call(m, "DeleteLoadBalancerRequest", arg0) 427 ret0, _ := ret[0].(*request.Request) 428 ret1, _ := ret[1].(*elbv2.DeleteLoadBalancerOutput) 429 return ret0, ret1 430 } 431 432 // DeleteLoadBalancerRequest indicates an expected call of DeleteLoadBalancerRequest 433 func (mr *MockELBV2APIMockRecorder) DeleteLoadBalancerRequest(arg0 interface{}) *gomock.Call { 434 mr.mock.ctrl.T.Helper() 435 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancerRequest", reflect.TypeOf((*MockELBV2API)(nil).DeleteLoadBalancerRequest), arg0) 436 } 437 438 // DeleteRule mocks base method 439 func (m *MockELBV2API) DeleteRule(arg0 *elbv2.DeleteRuleInput) (*elbv2.DeleteRuleOutput, error) { 440 m.ctrl.T.Helper() 441 ret := m.ctrl.Call(m, "DeleteRule", arg0) 442 ret0, _ := ret[0].(*elbv2.DeleteRuleOutput) 443 ret1, _ := ret[1].(error) 444 return ret0, ret1 445 } 446 447 // DeleteRule indicates an expected call of DeleteRule 448 func (mr *MockELBV2APIMockRecorder) DeleteRule(arg0 interface{}) *gomock.Call { 449 mr.mock.ctrl.T.Helper() 450 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRule", reflect.TypeOf((*MockELBV2API)(nil).DeleteRule), arg0) 451 } 452 453 // DeleteRuleWithContext mocks base method 454 func (m *MockELBV2API) DeleteRuleWithContext(arg0 aws.Context, arg1 *elbv2.DeleteRuleInput, arg2 ...request.Option) (*elbv2.DeleteRuleOutput, error) { 455 m.ctrl.T.Helper() 456 varargs := []interface{}{arg0, arg1} 457 for _, a := range arg2 { 458 varargs = append(varargs, a) 459 } 460 ret := m.ctrl.Call(m, "DeleteRuleWithContext", varargs...) 461 ret0, _ := ret[0].(*elbv2.DeleteRuleOutput) 462 ret1, _ := ret[1].(error) 463 return ret0, ret1 464 } 465 466 // DeleteRuleWithContext indicates an expected call of DeleteRuleWithContext 467 func (mr *MockELBV2APIMockRecorder) DeleteRuleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 468 mr.mock.ctrl.T.Helper() 469 varargs := append([]interface{}{arg0, arg1}, arg2...) 470 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRuleWithContext", reflect.TypeOf((*MockELBV2API)(nil).DeleteRuleWithContext), varargs...) 471 } 472 473 // DeleteRuleRequest mocks base method 474 func (m *MockELBV2API) DeleteRuleRequest(arg0 *elbv2.DeleteRuleInput) (*request.Request, *elbv2.DeleteRuleOutput) { 475 m.ctrl.T.Helper() 476 ret := m.ctrl.Call(m, "DeleteRuleRequest", arg0) 477 ret0, _ := ret[0].(*request.Request) 478 ret1, _ := ret[1].(*elbv2.DeleteRuleOutput) 479 return ret0, ret1 480 } 481 482 // DeleteRuleRequest indicates an expected call of DeleteRuleRequest 483 func (mr *MockELBV2APIMockRecorder) DeleteRuleRequest(arg0 interface{}) *gomock.Call { 484 mr.mock.ctrl.T.Helper() 485 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRuleRequest", reflect.TypeOf((*MockELBV2API)(nil).DeleteRuleRequest), arg0) 486 } 487 488 // DeleteTargetGroup mocks base method 489 func (m *MockELBV2API) DeleteTargetGroup(arg0 *elbv2.DeleteTargetGroupInput) (*elbv2.DeleteTargetGroupOutput, error) { 490 m.ctrl.T.Helper() 491 ret := m.ctrl.Call(m, "DeleteTargetGroup", arg0) 492 ret0, _ := ret[0].(*elbv2.DeleteTargetGroupOutput) 493 ret1, _ := ret[1].(error) 494 return ret0, ret1 495 } 496 497 // DeleteTargetGroup indicates an expected call of DeleteTargetGroup 498 func (mr *MockELBV2APIMockRecorder) DeleteTargetGroup(arg0 interface{}) *gomock.Call { 499 mr.mock.ctrl.T.Helper() 500 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTargetGroup", reflect.TypeOf((*MockELBV2API)(nil).DeleteTargetGroup), arg0) 501 } 502 503 // DeleteTargetGroupWithContext mocks base method 504 func (m *MockELBV2API) DeleteTargetGroupWithContext(arg0 aws.Context, arg1 *elbv2.DeleteTargetGroupInput, arg2 ...request.Option) (*elbv2.DeleteTargetGroupOutput, error) { 505 m.ctrl.T.Helper() 506 varargs := []interface{}{arg0, arg1} 507 for _, a := range arg2 { 508 varargs = append(varargs, a) 509 } 510 ret := m.ctrl.Call(m, "DeleteTargetGroupWithContext", varargs...) 511 ret0, _ := ret[0].(*elbv2.DeleteTargetGroupOutput) 512 ret1, _ := ret[1].(error) 513 return ret0, ret1 514 } 515 516 // DeleteTargetGroupWithContext indicates an expected call of DeleteTargetGroupWithContext 517 func (mr *MockELBV2APIMockRecorder) DeleteTargetGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 518 mr.mock.ctrl.T.Helper() 519 varargs := append([]interface{}{arg0, arg1}, arg2...) 520 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTargetGroupWithContext", reflect.TypeOf((*MockELBV2API)(nil).DeleteTargetGroupWithContext), varargs...) 521 } 522 523 // DeleteTargetGroupRequest mocks base method 524 func (m *MockELBV2API) DeleteTargetGroupRequest(arg0 *elbv2.DeleteTargetGroupInput) (*request.Request, *elbv2.DeleteTargetGroupOutput) { 525 m.ctrl.T.Helper() 526 ret := m.ctrl.Call(m, "DeleteTargetGroupRequest", arg0) 527 ret0, _ := ret[0].(*request.Request) 528 ret1, _ := ret[1].(*elbv2.DeleteTargetGroupOutput) 529 return ret0, ret1 530 } 531 532 // DeleteTargetGroupRequest indicates an expected call of DeleteTargetGroupRequest 533 func (mr *MockELBV2APIMockRecorder) DeleteTargetGroupRequest(arg0 interface{}) *gomock.Call { 534 mr.mock.ctrl.T.Helper() 535 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTargetGroupRequest", reflect.TypeOf((*MockELBV2API)(nil).DeleteTargetGroupRequest), arg0) 536 } 537 538 // DeregisterTargets mocks base method 539 func (m *MockELBV2API) DeregisterTargets(arg0 *elbv2.DeregisterTargetsInput) (*elbv2.DeregisterTargetsOutput, error) { 540 m.ctrl.T.Helper() 541 ret := m.ctrl.Call(m, "DeregisterTargets", arg0) 542 ret0, _ := ret[0].(*elbv2.DeregisterTargetsOutput) 543 ret1, _ := ret[1].(error) 544 return ret0, ret1 545 } 546 547 // DeregisterTargets indicates an expected call of DeregisterTargets 548 func (mr *MockELBV2APIMockRecorder) DeregisterTargets(arg0 interface{}) *gomock.Call { 549 mr.mock.ctrl.T.Helper() 550 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTargets", reflect.TypeOf((*MockELBV2API)(nil).DeregisterTargets), arg0) 551 } 552 553 // DeregisterTargetsWithContext mocks base method 554 func (m *MockELBV2API) DeregisterTargetsWithContext(arg0 aws.Context, arg1 *elbv2.DeregisterTargetsInput, arg2 ...request.Option) (*elbv2.DeregisterTargetsOutput, error) { 555 m.ctrl.T.Helper() 556 varargs := []interface{}{arg0, arg1} 557 for _, a := range arg2 { 558 varargs = append(varargs, a) 559 } 560 ret := m.ctrl.Call(m, "DeregisterTargetsWithContext", varargs...) 561 ret0, _ := ret[0].(*elbv2.DeregisterTargetsOutput) 562 ret1, _ := ret[1].(error) 563 return ret0, ret1 564 } 565 566 // DeregisterTargetsWithContext indicates an expected call of DeregisterTargetsWithContext 567 func (mr *MockELBV2APIMockRecorder) DeregisterTargetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 568 mr.mock.ctrl.T.Helper() 569 varargs := append([]interface{}{arg0, arg1}, arg2...) 570 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTargetsWithContext", reflect.TypeOf((*MockELBV2API)(nil).DeregisterTargetsWithContext), varargs...) 571 } 572 573 // DeregisterTargetsRequest mocks base method 574 func (m *MockELBV2API) DeregisterTargetsRequest(arg0 *elbv2.DeregisterTargetsInput) (*request.Request, *elbv2.DeregisterTargetsOutput) { 575 m.ctrl.T.Helper() 576 ret := m.ctrl.Call(m, "DeregisterTargetsRequest", arg0) 577 ret0, _ := ret[0].(*request.Request) 578 ret1, _ := ret[1].(*elbv2.DeregisterTargetsOutput) 579 return ret0, ret1 580 } 581 582 // DeregisterTargetsRequest indicates an expected call of DeregisterTargetsRequest 583 func (mr *MockELBV2APIMockRecorder) DeregisterTargetsRequest(arg0 interface{}) *gomock.Call { 584 mr.mock.ctrl.T.Helper() 585 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTargetsRequest", reflect.TypeOf((*MockELBV2API)(nil).DeregisterTargetsRequest), arg0) 586 } 587 588 // DescribeAccountLimits mocks base method 589 func (m *MockELBV2API) DescribeAccountLimits(arg0 *elbv2.DescribeAccountLimitsInput) (*elbv2.DescribeAccountLimitsOutput, error) { 590 m.ctrl.T.Helper() 591 ret := m.ctrl.Call(m, "DescribeAccountLimits", arg0) 592 ret0, _ := ret[0].(*elbv2.DescribeAccountLimitsOutput) 593 ret1, _ := ret[1].(error) 594 return ret0, ret1 595 } 596 597 // DescribeAccountLimits indicates an expected call of DescribeAccountLimits 598 func (mr *MockELBV2APIMockRecorder) DescribeAccountLimits(arg0 interface{}) *gomock.Call { 599 mr.mock.ctrl.T.Helper() 600 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountLimits", reflect.TypeOf((*MockELBV2API)(nil).DescribeAccountLimits), arg0) 601 } 602 603 // DescribeAccountLimitsWithContext mocks base method 604 func (m *MockELBV2API) DescribeAccountLimitsWithContext(arg0 aws.Context, arg1 *elbv2.DescribeAccountLimitsInput, arg2 ...request.Option) (*elbv2.DescribeAccountLimitsOutput, error) { 605 m.ctrl.T.Helper() 606 varargs := []interface{}{arg0, arg1} 607 for _, a := range arg2 { 608 varargs = append(varargs, a) 609 } 610 ret := m.ctrl.Call(m, "DescribeAccountLimitsWithContext", varargs...) 611 ret0, _ := ret[0].(*elbv2.DescribeAccountLimitsOutput) 612 ret1, _ := ret[1].(error) 613 return ret0, ret1 614 } 615 616 // DescribeAccountLimitsWithContext indicates an expected call of DescribeAccountLimitsWithContext 617 func (mr *MockELBV2APIMockRecorder) DescribeAccountLimitsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 618 mr.mock.ctrl.T.Helper() 619 varargs := append([]interface{}{arg0, arg1}, arg2...) 620 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountLimitsWithContext", reflect.TypeOf((*MockELBV2API)(nil).DescribeAccountLimitsWithContext), varargs...) 621 } 622 623 // DescribeAccountLimitsRequest mocks base method 624 func (m *MockELBV2API) DescribeAccountLimitsRequest(arg0 *elbv2.DescribeAccountLimitsInput) (*request.Request, *elbv2.DescribeAccountLimitsOutput) { 625 m.ctrl.T.Helper() 626 ret := m.ctrl.Call(m, "DescribeAccountLimitsRequest", arg0) 627 ret0, _ := ret[0].(*request.Request) 628 ret1, _ := ret[1].(*elbv2.DescribeAccountLimitsOutput) 629 return ret0, ret1 630 } 631 632 // DescribeAccountLimitsRequest indicates an expected call of DescribeAccountLimitsRequest 633 func (mr *MockELBV2APIMockRecorder) DescribeAccountLimitsRequest(arg0 interface{}) *gomock.Call { 634 mr.mock.ctrl.T.Helper() 635 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountLimitsRequest", reflect.TypeOf((*MockELBV2API)(nil).DescribeAccountLimitsRequest), arg0) 636 } 637 638 // DescribeListenerCertificates mocks base method 639 func (m *MockELBV2API) DescribeListenerCertificates(arg0 *elbv2.DescribeListenerCertificatesInput) (*elbv2.DescribeListenerCertificatesOutput, error) { 640 m.ctrl.T.Helper() 641 ret := m.ctrl.Call(m, "DescribeListenerCertificates", arg0) 642 ret0, _ := ret[0].(*elbv2.DescribeListenerCertificatesOutput) 643 ret1, _ := ret[1].(error) 644 return ret0, ret1 645 } 646 647 // DescribeListenerCertificates indicates an expected call of DescribeListenerCertificates 648 func (mr *MockELBV2APIMockRecorder) DescribeListenerCertificates(arg0 interface{}) *gomock.Call { 649 mr.mock.ctrl.T.Helper() 650 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeListenerCertificates", reflect.TypeOf((*MockELBV2API)(nil).DescribeListenerCertificates), arg0) 651 } 652 653 // DescribeListenerCertificatesWithContext mocks base method 654 func (m *MockELBV2API) DescribeListenerCertificatesWithContext(arg0 aws.Context, arg1 *elbv2.DescribeListenerCertificatesInput, arg2 ...request.Option) (*elbv2.DescribeListenerCertificatesOutput, error) { 655 m.ctrl.T.Helper() 656 varargs := []interface{}{arg0, arg1} 657 for _, a := range arg2 { 658 varargs = append(varargs, a) 659 } 660 ret := m.ctrl.Call(m, "DescribeListenerCertificatesWithContext", varargs...) 661 ret0, _ := ret[0].(*elbv2.DescribeListenerCertificatesOutput) 662 ret1, _ := ret[1].(error) 663 return ret0, ret1 664 } 665 666 // DescribeListenerCertificatesWithContext indicates an expected call of DescribeListenerCertificatesWithContext 667 func (mr *MockELBV2APIMockRecorder) DescribeListenerCertificatesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 668 mr.mock.ctrl.T.Helper() 669 varargs := append([]interface{}{arg0, arg1}, arg2...) 670 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeListenerCertificatesWithContext", reflect.TypeOf((*MockELBV2API)(nil).DescribeListenerCertificatesWithContext), varargs...) 671 } 672 673 // DescribeListenerCertificatesRequest mocks base method 674 func (m *MockELBV2API) DescribeListenerCertificatesRequest(arg0 *elbv2.DescribeListenerCertificatesInput) (*request.Request, *elbv2.DescribeListenerCertificatesOutput) { 675 m.ctrl.T.Helper() 676 ret := m.ctrl.Call(m, "DescribeListenerCertificatesRequest", arg0) 677 ret0, _ := ret[0].(*request.Request) 678 ret1, _ := ret[1].(*elbv2.DescribeListenerCertificatesOutput) 679 return ret0, ret1 680 } 681 682 // DescribeListenerCertificatesRequest indicates an expected call of DescribeListenerCertificatesRequest 683 func (mr *MockELBV2APIMockRecorder) DescribeListenerCertificatesRequest(arg0 interface{}) *gomock.Call { 684 mr.mock.ctrl.T.Helper() 685 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeListenerCertificatesRequest", reflect.TypeOf((*MockELBV2API)(nil).DescribeListenerCertificatesRequest), arg0) 686 } 687 688 // DescribeListeners mocks base method 689 func (m *MockELBV2API) DescribeListeners(arg0 *elbv2.DescribeListenersInput) (*elbv2.DescribeListenersOutput, error) { 690 m.ctrl.T.Helper() 691 ret := m.ctrl.Call(m, "DescribeListeners", arg0) 692 ret0, _ := ret[0].(*elbv2.DescribeListenersOutput) 693 ret1, _ := ret[1].(error) 694 return ret0, ret1 695 } 696 697 // DescribeListeners indicates an expected call of DescribeListeners 698 func (mr *MockELBV2APIMockRecorder) DescribeListeners(arg0 interface{}) *gomock.Call { 699 mr.mock.ctrl.T.Helper() 700 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeListeners", reflect.TypeOf((*MockELBV2API)(nil).DescribeListeners), arg0) 701 } 702 703 // DescribeListenersWithContext mocks base method 704 func (m *MockELBV2API) DescribeListenersWithContext(arg0 aws.Context, arg1 *elbv2.DescribeListenersInput, arg2 ...request.Option) (*elbv2.DescribeListenersOutput, error) { 705 m.ctrl.T.Helper() 706 varargs := []interface{}{arg0, arg1} 707 for _, a := range arg2 { 708 varargs = append(varargs, a) 709 } 710 ret := m.ctrl.Call(m, "DescribeListenersWithContext", varargs...) 711 ret0, _ := ret[0].(*elbv2.DescribeListenersOutput) 712 ret1, _ := ret[1].(error) 713 return ret0, ret1 714 } 715 716 // DescribeListenersWithContext indicates an expected call of DescribeListenersWithContext 717 func (mr *MockELBV2APIMockRecorder) DescribeListenersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 718 mr.mock.ctrl.T.Helper() 719 varargs := append([]interface{}{arg0, arg1}, arg2...) 720 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeListenersWithContext", reflect.TypeOf((*MockELBV2API)(nil).DescribeListenersWithContext), varargs...) 721 } 722 723 // DescribeListenersRequest mocks base method 724 func (m *MockELBV2API) DescribeListenersRequest(arg0 *elbv2.DescribeListenersInput) (*request.Request, *elbv2.DescribeListenersOutput) { 725 m.ctrl.T.Helper() 726 ret := m.ctrl.Call(m, "DescribeListenersRequest", arg0) 727 ret0, _ := ret[0].(*request.Request) 728 ret1, _ := ret[1].(*elbv2.DescribeListenersOutput) 729 return ret0, ret1 730 } 731 732 // DescribeListenersRequest indicates an expected call of DescribeListenersRequest 733 func (mr *MockELBV2APIMockRecorder) DescribeListenersRequest(arg0 interface{}) *gomock.Call { 734 mr.mock.ctrl.T.Helper() 735 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeListenersRequest", reflect.TypeOf((*MockELBV2API)(nil).DescribeListenersRequest), arg0) 736 } 737 738 // DescribeListenersPages mocks base method 739 func (m *MockELBV2API) DescribeListenersPages(arg0 *elbv2.DescribeListenersInput, arg1 func(*elbv2.DescribeListenersOutput, bool) bool) error { 740 m.ctrl.T.Helper() 741 ret := m.ctrl.Call(m, "DescribeListenersPages", arg0, arg1) 742 ret0, _ := ret[0].(error) 743 return ret0 744 } 745 746 // DescribeListenersPages indicates an expected call of DescribeListenersPages 747 func (mr *MockELBV2APIMockRecorder) DescribeListenersPages(arg0, arg1 interface{}) *gomock.Call { 748 mr.mock.ctrl.T.Helper() 749 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeListenersPages", reflect.TypeOf((*MockELBV2API)(nil).DescribeListenersPages), arg0, arg1) 750 } 751 752 // DescribeListenersPagesWithContext mocks base method 753 func (m *MockELBV2API) DescribeListenersPagesWithContext(arg0 aws.Context, arg1 *elbv2.DescribeListenersInput, arg2 func(*elbv2.DescribeListenersOutput, bool) bool, arg3 ...request.Option) error { 754 m.ctrl.T.Helper() 755 varargs := []interface{}{arg0, arg1, arg2} 756 for _, a := range arg3 { 757 varargs = append(varargs, a) 758 } 759 ret := m.ctrl.Call(m, "DescribeListenersPagesWithContext", varargs...) 760 ret0, _ := ret[0].(error) 761 return ret0 762 } 763 764 // DescribeListenersPagesWithContext indicates an expected call of DescribeListenersPagesWithContext 765 func (mr *MockELBV2APIMockRecorder) DescribeListenersPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 766 mr.mock.ctrl.T.Helper() 767 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 768 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeListenersPagesWithContext", reflect.TypeOf((*MockELBV2API)(nil).DescribeListenersPagesWithContext), varargs...) 769 } 770 771 // DescribeLoadBalancerAttributes mocks base method 772 func (m *MockELBV2API) DescribeLoadBalancerAttributes(arg0 *elbv2.DescribeLoadBalancerAttributesInput) (*elbv2.DescribeLoadBalancerAttributesOutput, error) { 773 m.ctrl.T.Helper() 774 ret := m.ctrl.Call(m, "DescribeLoadBalancerAttributes", arg0) 775 ret0, _ := ret[0].(*elbv2.DescribeLoadBalancerAttributesOutput) 776 ret1, _ := ret[1].(error) 777 return ret0, ret1 778 } 779 780 // DescribeLoadBalancerAttributes indicates an expected call of DescribeLoadBalancerAttributes 781 func (mr *MockELBV2APIMockRecorder) DescribeLoadBalancerAttributes(arg0 interface{}) *gomock.Call { 782 mr.mock.ctrl.T.Helper() 783 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerAttributes", reflect.TypeOf((*MockELBV2API)(nil).DescribeLoadBalancerAttributes), arg0) 784 } 785 786 // DescribeLoadBalancerAttributesWithContext mocks base method 787 func (m *MockELBV2API) DescribeLoadBalancerAttributesWithContext(arg0 aws.Context, arg1 *elbv2.DescribeLoadBalancerAttributesInput, arg2 ...request.Option) (*elbv2.DescribeLoadBalancerAttributesOutput, error) { 788 m.ctrl.T.Helper() 789 varargs := []interface{}{arg0, arg1} 790 for _, a := range arg2 { 791 varargs = append(varargs, a) 792 } 793 ret := m.ctrl.Call(m, "DescribeLoadBalancerAttributesWithContext", varargs...) 794 ret0, _ := ret[0].(*elbv2.DescribeLoadBalancerAttributesOutput) 795 ret1, _ := ret[1].(error) 796 return ret0, ret1 797 } 798 799 // DescribeLoadBalancerAttributesWithContext indicates an expected call of DescribeLoadBalancerAttributesWithContext 800 func (mr *MockELBV2APIMockRecorder) DescribeLoadBalancerAttributesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 801 mr.mock.ctrl.T.Helper() 802 varargs := append([]interface{}{arg0, arg1}, arg2...) 803 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerAttributesWithContext", reflect.TypeOf((*MockELBV2API)(nil).DescribeLoadBalancerAttributesWithContext), varargs...) 804 } 805 806 // DescribeLoadBalancerAttributesRequest mocks base method 807 func (m *MockELBV2API) DescribeLoadBalancerAttributesRequest(arg0 *elbv2.DescribeLoadBalancerAttributesInput) (*request.Request, *elbv2.DescribeLoadBalancerAttributesOutput) { 808 m.ctrl.T.Helper() 809 ret := m.ctrl.Call(m, "DescribeLoadBalancerAttributesRequest", arg0) 810 ret0, _ := ret[0].(*request.Request) 811 ret1, _ := ret[1].(*elbv2.DescribeLoadBalancerAttributesOutput) 812 return ret0, ret1 813 } 814 815 // DescribeLoadBalancerAttributesRequest indicates an expected call of DescribeLoadBalancerAttributesRequest 816 func (mr *MockELBV2APIMockRecorder) DescribeLoadBalancerAttributesRequest(arg0 interface{}) *gomock.Call { 817 mr.mock.ctrl.T.Helper() 818 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerAttributesRequest", reflect.TypeOf((*MockELBV2API)(nil).DescribeLoadBalancerAttributesRequest), arg0) 819 } 820 821 // DescribeLoadBalancers mocks base method 822 func (m *MockELBV2API) DescribeLoadBalancers(arg0 *elbv2.DescribeLoadBalancersInput) (*elbv2.DescribeLoadBalancersOutput, error) { 823 m.ctrl.T.Helper() 824 ret := m.ctrl.Call(m, "DescribeLoadBalancers", arg0) 825 ret0, _ := ret[0].(*elbv2.DescribeLoadBalancersOutput) 826 ret1, _ := ret[1].(error) 827 return ret0, ret1 828 } 829 830 // DescribeLoadBalancers indicates an expected call of DescribeLoadBalancers 831 func (mr *MockELBV2APIMockRecorder) DescribeLoadBalancers(arg0 interface{}) *gomock.Call { 832 mr.mock.ctrl.T.Helper() 833 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancers", reflect.TypeOf((*MockELBV2API)(nil).DescribeLoadBalancers), arg0) 834 } 835 836 // DescribeLoadBalancersWithContext mocks base method 837 func (m *MockELBV2API) DescribeLoadBalancersWithContext(arg0 aws.Context, arg1 *elbv2.DescribeLoadBalancersInput, arg2 ...request.Option) (*elbv2.DescribeLoadBalancersOutput, error) { 838 m.ctrl.T.Helper() 839 varargs := []interface{}{arg0, arg1} 840 for _, a := range arg2 { 841 varargs = append(varargs, a) 842 } 843 ret := m.ctrl.Call(m, "DescribeLoadBalancersWithContext", varargs...) 844 ret0, _ := ret[0].(*elbv2.DescribeLoadBalancersOutput) 845 ret1, _ := ret[1].(error) 846 return ret0, ret1 847 } 848 849 // DescribeLoadBalancersWithContext indicates an expected call of DescribeLoadBalancersWithContext 850 func (mr *MockELBV2APIMockRecorder) DescribeLoadBalancersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 851 mr.mock.ctrl.T.Helper() 852 varargs := append([]interface{}{arg0, arg1}, arg2...) 853 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancersWithContext", reflect.TypeOf((*MockELBV2API)(nil).DescribeLoadBalancersWithContext), varargs...) 854 } 855 856 // DescribeLoadBalancersRequest mocks base method 857 func (m *MockELBV2API) DescribeLoadBalancersRequest(arg0 *elbv2.DescribeLoadBalancersInput) (*request.Request, *elbv2.DescribeLoadBalancersOutput) { 858 m.ctrl.T.Helper() 859 ret := m.ctrl.Call(m, "DescribeLoadBalancersRequest", arg0) 860 ret0, _ := ret[0].(*request.Request) 861 ret1, _ := ret[1].(*elbv2.DescribeLoadBalancersOutput) 862 return ret0, ret1 863 } 864 865 // DescribeLoadBalancersRequest indicates an expected call of DescribeLoadBalancersRequest 866 func (mr *MockELBV2APIMockRecorder) DescribeLoadBalancersRequest(arg0 interface{}) *gomock.Call { 867 mr.mock.ctrl.T.Helper() 868 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancersRequest", reflect.TypeOf((*MockELBV2API)(nil).DescribeLoadBalancersRequest), arg0) 869 } 870 871 // DescribeLoadBalancersPages mocks base method 872 func (m *MockELBV2API) DescribeLoadBalancersPages(arg0 *elbv2.DescribeLoadBalancersInput, arg1 func(*elbv2.DescribeLoadBalancersOutput, bool) bool) error { 873 m.ctrl.T.Helper() 874 ret := m.ctrl.Call(m, "DescribeLoadBalancersPages", arg0, arg1) 875 ret0, _ := ret[0].(error) 876 return ret0 877 } 878 879 // DescribeLoadBalancersPages indicates an expected call of DescribeLoadBalancersPages 880 func (mr *MockELBV2APIMockRecorder) DescribeLoadBalancersPages(arg0, arg1 interface{}) *gomock.Call { 881 mr.mock.ctrl.T.Helper() 882 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancersPages", reflect.TypeOf((*MockELBV2API)(nil).DescribeLoadBalancersPages), arg0, arg1) 883 } 884 885 // DescribeLoadBalancersPagesWithContext mocks base method 886 func (m *MockELBV2API) DescribeLoadBalancersPagesWithContext(arg0 aws.Context, arg1 *elbv2.DescribeLoadBalancersInput, arg2 func(*elbv2.DescribeLoadBalancersOutput, bool) bool, arg3 ...request.Option) error { 887 m.ctrl.T.Helper() 888 varargs := []interface{}{arg0, arg1, arg2} 889 for _, a := range arg3 { 890 varargs = append(varargs, a) 891 } 892 ret := m.ctrl.Call(m, "DescribeLoadBalancersPagesWithContext", varargs...) 893 ret0, _ := ret[0].(error) 894 return ret0 895 } 896 897 // DescribeLoadBalancersPagesWithContext indicates an expected call of DescribeLoadBalancersPagesWithContext 898 func (mr *MockELBV2APIMockRecorder) DescribeLoadBalancersPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 899 mr.mock.ctrl.T.Helper() 900 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 901 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancersPagesWithContext", reflect.TypeOf((*MockELBV2API)(nil).DescribeLoadBalancersPagesWithContext), varargs...) 902 } 903 904 // DescribeRules mocks base method 905 func (m *MockELBV2API) DescribeRules(arg0 *elbv2.DescribeRulesInput) (*elbv2.DescribeRulesOutput, error) { 906 m.ctrl.T.Helper() 907 ret := m.ctrl.Call(m, "DescribeRules", arg0) 908 ret0, _ := ret[0].(*elbv2.DescribeRulesOutput) 909 ret1, _ := ret[1].(error) 910 return ret0, ret1 911 } 912 913 // DescribeRules indicates an expected call of DescribeRules 914 func (mr *MockELBV2APIMockRecorder) DescribeRules(arg0 interface{}) *gomock.Call { 915 mr.mock.ctrl.T.Helper() 916 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRules", reflect.TypeOf((*MockELBV2API)(nil).DescribeRules), arg0) 917 } 918 919 // DescribeRulesWithContext mocks base method 920 func (m *MockELBV2API) DescribeRulesWithContext(arg0 aws.Context, arg1 *elbv2.DescribeRulesInput, arg2 ...request.Option) (*elbv2.DescribeRulesOutput, error) { 921 m.ctrl.T.Helper() 922 varargs := []interface{}{arg0, arg1} 923 for _, a := range arg2 { 924 varargs = append(varargs, a) 925 } 926 ret := m.ctrl.Call(m, "DescribeRulesWithContext", varargs...) 927 ret0, _ := ret[0].(*elbv2.DescribeRulesOutput) 928 ret1, _ := ret[1].(error) 929 return ret0, ret1 930 } 931 932 // DescribeRulesWithContext indicates an expected call of DescribeRulesWithContext 933 func (mr *MockELBV2APIMockRecorder) DescribeRulesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 934 mr.mock.ctrl.T.Helper() 935 varargs := append([]interface{}{arg0, arg1}, arg2...) 936 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRulesWithContext", reflect.TypeOf((*MockELBV2API)(nil).DescribeRulesWithContext), varargs...) 937 } 938 939 // DescribeRulesRequest mocks base method 940 func (m *MockELBV2API) DescribeRulesRequest(arg0 *elbv2.DescribeRulesInput) (*request.Request, *elbv2.DescribeRulesOutput) { 941 m.ctrl.T.Helper() 942 ret := m.ctrl.Call(m, "DescribeRulesRequest", arg0) 943 ret0, _ := ret[0].(*request.Request) 944 ret1, _ := ret[1].(*elbv2.DescribeRulesOutput) 945 return ret0, ret1 946 } 947 948 // DescribeRulesRequest indicates an expected call of DescribeRulesRequest 949 func (mr *MockELBV2APIMockRecorder) DescribeRulesRequest(arg0 interface{}) *gomock.Call { 950 mr.mock.ctrl.T.Helper() 951 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRulesRequest", reflect.TypeOf((*MockELBV2API)(nil).DescribeRulesRequest), arg0) 952 } 953 954 // DescribeSSLPolicies mocks base method 955 func (m *MockELBV2API) DescribeSSLPolicies(arg0 *elbv2.DescribeSSLPoliciesInput) (*elbv2.DescribeSSLPoliciesOutput, error) { 956 m.ctrl.T.Helper() 957 ret := m.ctrl.Call(m, "DescribeSSLPolicies", arg0) 958 ret0, _ := ret[0].(*elbv2.DescribeSSLPoliciesOutput) 959 ret1, _ := ret[1].(error) 960 return ret0, ret1 961 } 962 963 // DescribeSSLPolicies indicates an expected call of DescribeSSLPolicies 964 func (mr *MockELBV2APIMockRecorder) DescribeSSLPolicies(arg0 interface{}) *gomock.Call { 965 mr.mock.ctrl.T.Helper() 966 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSSLPolicies", reflect.TypeOf((*MockELBV2API)(nil).DescribeSSLPolicies), arg0) 967 } 968 969 // DescribeSSLPoliciesWithContext mocks base method 970 func (m *MockELBV2API) DescribeSSLPoliciesWithContext(arg0 aws.Context, arg1 *elbv2.DescribeSSLPoliciesInput, arg2 ...request.Option) (*elbv2.DescribeSSLPoliciesOutput, error) { 971 m.ctrl.T.Helper() 972 varargs := []interface{}{arg0, arg1} 973 for _, a := range arg2 { 974 varargs = append(varargs, a) 975 } 976 ret := m.ctrl.Call(m, "DescribeSSLPoliciesWithContext", varargs...) 977 ret0, _ := ret[0].(*elbv2.DescribeSSLPoliciesOutput) 978 ret1, _ := ret[1].(error) 979 return ret0, ret1 980 } 981 982 // DescribeSSLPoliciesWithContext indicates an expected call of DescribeSSLPoliciesWithContext 983 func (mr *MockELBV2APIMockRecorder) DescribeSSLPoliciesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 984 mr.mock.ctrl.T.Helper() 985 varargs := append([]interface{}{arg0, arg1}, arg2...) 986 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSSLPoliciesWithContext", reflect.TypeOf((*MockELBV2API)(nil).DescribeSSLPoliciesWithContext), varargs...) 987 } 988 989 // DescribeSSLPoliciesRequest mocks base method 990 func (m *MockELBV2API) DescribeSSLPoliciesRequest(arg0 *elbv2.DescribeSSLPoliciesInput) (*request.Request, *elbv2.DescribeSSLPoliciesOutput) { 991 m.ctrl.T.Helper() 992 ret := m.ctrl.Call(m, "DescribeSSLPoliciesRequest", arg0) 993 ret0, _ := ret[0].(*request.Request) 994 ret1, _ := ret[1].(*elbv2.DescribeSSLPoliciesOutput) 995 return ret0, ret1 996 } 997 998 // DescribeSSLPoliciesRequest indicates an expected call of DescribeSSLPoliciesRequest 999 func (mr *MockELBV2APIMockRecorder) DescribeSSLPoliciesRequest(arg0 interface{}) *gomock.Call { 1000 mr.mock.ctrl.T.Helper() 1001 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSSLPoliciesRequest", reflect.TypeOf((*MockELBV2API)(nil).DescribeSSLPoliciesRequest), arg0) 1002 } 1003 1004 // DescribeTags mocks base method 1005 func (m *MockELBV2API) DescribeTags(arg0 *elbv2.DescribeTagsInput) (*elbv2.DescribeTagsOutput, error) { 1006 m.ctrl.T.Helper() 1007 ret := m.ctrl.Call(m, "DescribeTags", arg0) 1008 ret0, _ := ret[0].(*elbv2.DescribeTagsOutput) 1009 ret1, _ := ret[1].(error) 1010 return ret0, ret1 1011 } 1012 1013 // DescribeTags indicates an expected call of DescribeTags 1014 func (mr *MockELBV2APIMockRecorder) DescribeTags(arg0 interface{}) *gomock.Call { 1015 mr.mock.ctrl.T.Helper() 1016 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTags", reflect.TypeOf((*MockELBV2API)(nil).DescribeTags), arg0) 1017 } 1018 1019 // DescribeTagsWithContext mocks base method 1020 func (m *MockELBV2API) DescribeTagsWithContext(arg0 aws.Context, arg1 *elbv2.DescribeTagsInput, arg2 ...request.Option) (*elbv2.DescribeTagsOutput, error) { 1021 m.ctrl.T.Helper() 1022 varargs := []interface{}{arg0, arg1} 1023 for _, a := range arg2 { 1024 varargs = append(varargs, a) 1025 } 1026 ret := m.ctrl.Call(m, "DescribeTagsWithContext", varargs...) 1027 ret0, _ := ret[0].(*elbv2.DescribeTagsOutput) 1028 ret1, _ := ret[1].(error) 1029 return ret0, ret1 1030 } 1031 1032 // DescribeTagsWithContext indicates an expected call of DescribeTagsWithContext 1033 func (mr *MockELBV2APIMockRecorder) DescribeTagsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1034 mr.mock.ctrl.T.Helper() 1035 varargs := append([]interface{}{arg0, arg1}, arg2...) 1036 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsWithContext", reflect.TypeOf((*MockELBV2API)(nil).DescribeTagsWithContext), varargs...) 1037 } 1038 1039 // DescribeTagsRequest mocks base method 1040 func (m *MockELBV2API) DescribeTagsRequest(arg0 *elbv2.DescribeTagsInput) (*request.Request, *elbv2.DescribeTagsOutput) { 1041 m.ctrl.T.Helper() 1042 ret := m.ctrl.Call(m, "DescribeTagsRequest", arg0) 1043 ret0, _ := ret[0].(*request.Request) 1044 ret1, _ := ret[1].(*elbv2.DescribeTagsOutput) 1045 return ret0, ret1 1046 } 1047 1048 // DescribeTagsRequest indicates an expected call of DescribeTagsRequest 1049 func (mr *MockELBV2APIMockRecorder) DescribeTagsRequest(arg0 interface{}) *gomock.Call { 1050 mr.mock.ctrl.T.Helper() 1051 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsRequest", reflect.TypeOf((*MockELBV2API)(nil).DescribeTagsRequest), arg0) 1052 } 1053 1054 // DescribeTargetGroupAttributes mocks base method 1055 func (m *MockELBV2API) DescribeTargetGroupAttributes(arg0 *elbv2.DescribeTargetGroupAttributesInput) (*elbv2.DescribeTargetGroupAttributesOutput, error) { 1056 m.ctrl.T.Helper() 1057 ret := m.ctrl.Call(m, "DescribeTargetGroupAttributes", arg0) 1058 ret0, _ := ret[0].(*elbv2.DescribeTargetGroupAttributesOutput) 1059 ret1, _ := ret[1].(error) 1060 return ret0, ret1 1061 } 1062 1063 // DescribeTargetGroupAttributes indicates an expected call of DescribeTargetGroupAttributes 1064 func (mr *MockELBV2APIMockRecorder) DescribeTargetGroupAttributes(arg0 interface{}) *gomock.Call { 1065 mr.mock.ctrl.T.Helper() 1066 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetGroupAttributes", reflect.TypeOf((*MockELBV2API)(nil).DescribeTargetGroupAttributes), arg0) 1067 } 1068 1069 // DescribeTargetGroupAttributesWithContext mocks base method 1070 func (m *MockELBV2API) DescribeTargetGroupAttributesWithContext(arg0 aws.Context, arg1 *elbv2.DescribeTargetGroupAttributesInput, arg2 ...request.Option) (*elbv2.DescribeTargetGroupAttributesOutput, error) { 1071 m.ctrl.T.Helper() 1072 varargs := []interface{}{arg0, arg1} 1073 for _, a := range arg2 { 1074 varargs = append(varargs, a) 1075 } 1076 ret := m.ctrl.Call(m, "DescribeTargetGroupAttributesWithContext", varargs...) 1077 ret0, _ := ret[0].(*elbv2.DescribeTargetGroupAttributesOutput) 1078 ret1, _ := ret[1].(error) 1079 return ret0, ret1 1080 } 1081 1082 // DescribeTargetGroupAttributesWithContext indicates an expected call of DescribeTargetGroupAttributesWithContext 1083 func (mr *MockELBV2APIMockRecorder) DescribeTargetGroupAttributesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1084 mr.mock.ctrl.T.Helper() 1085 varargs := append([]interface{}{arg0, arg1}, arg2...) 1086 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetGroupAttributesWithContext", reflect.TypeOf((*MockELBV2API)(nil).DescribeTargetGroupAttributesWithContext), varargs...) 1087 } 1088 1089 // DescribeTargetGroupAttributesRequest mocks base method 1090 func (m *MockELBV2API) DescribeTargetGroupAttributesRequest(arg0 *elbv2.DescribeTargetGroupAttributesInput) (*request.Request, *elbv2.DescribeTargetGroupAttributesOutput) { 1091 m.ctrl.T.Helper() 1092 ret := m.ctrl.Call(m, "DescribeTargetGroupAttributesRequest", arg0) 1093 ret0, _ := ret[0].(*request.Request) 1094 ret1, _ := ret[1].(*elbv2.DescribeTargetGroupAttributesOutput) 1095 return ret0, ret1 1096 } 1097 1098 // DescribeTargetGroupAttributesRequest indicates an expected call of DescribeTargetGroupAttributesRequest 1099 func (mr *MockELBV2APIMockRecorder) DescribeTargetGroupAttributesRequest(arg0 interface{}) *gomock.Call { 1100 mr.mock.ctrl.T.Helper() 1101 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetGroupAttributesRequest", reflect.TypeOf((*MockELBV2API)(nil).DescribeTargetGroupAttributesRequest), arg0) 1102 } 1103 1104 // DescribeTargetGroups mocks base method 1105 func (m *MockELBV2API) DescribeTargetGroups(arg0 *elbv2.DescribeTargetGroupsInput) (*elbv2.DescribeTargetGroupsOutput, error) { 1106 m.ctrl.T.Helper() 1107 ret := m.ctrl.Call(m, "DescribeTargetGroups", arg0) 1108 ret0, _ := ret[0].(*elbv2.DescribeTargetGroupsOutput) 1109 ret1, _ := ret[1].(error) 1110 return ret0, ret1 1111 } 1112 1113 // DescribeTargetGroups indicates an expected call of DescribeTargetGroups 1114 func (mr *MockELBV2APIMockRecorder) DescribeTargetGroups(arg0 interface{}) *gomock.Call { 1115 mr.mock.ctrl.T.Helper() 1116 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetGroups", reflect.TypeOf((*MockELBV2API)(nil).DescribeTargetGroups), arg0) 1117 } 1118 1119 // DescribeTargetGroupsWithContext mocks base method 1120 func (m *MockELBV2API) DescribeTargetGroupsWithContext(arg0 aws.Context, arg1 *elbv2.DescribeTargetGroupsInput, arg2 ...request.Option) (*elbv2.DescribeTargetGroupsOutput, error) { 1121 m.ctrl.T.Helper() 1122 varargs := []interface{}{arg0, arg1} 1123 for _, a := range arg2 { 1124 varargs = append(varargs, a) 1125 } 1126 ret := m.ctrl.Call(m, "DescribeTargetGroupsWithContext", varargs...) 1127 ret0, _ := ret[0].(*elbv2.DescribeTargetGroupsOutput) 1128 ret1, _ := ret[1].(error) 1129 return ret0, ret1 1130 } 1131 1132 // DescribeTargetGroupsWithContext indicates an expected call of DescribeTargetGroupsWithContext 1133 func (mr *MockELBV2APIMockRecorder) DescribeTargetGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1134 mr.mock.ctrl.T.Helper() 1135 varargs := append([]interface{}{arg0, arg1}, arg2...) 1136 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetGroupsWithContext", reflect.TypeOf((*MockELBV2API)(nil).DescribeTargetGroupsWithContext), varargs...) 1137 } 1138 1139 // DescribeTargetGroupsRequest mocks base method 1140 func (m *MockELBV2API) DescribeTargetGroupsRequest(arg0 *elbv2.DescribeTargetGroupsInput) (*request.Request, *elbv2.DescribeTargetGroupsOutput) { 1141 m.ctrl.T.Helper() 1142 ret := m.ctrl.Call(m, "DescribeTargetGroupsRequest", arg0) 1143 ret0, _ := ret[0].(*request.Request) 1144 ret1, _ := ret[1].(*elbv2.DescribeTargetGroupsOutput) 1145 return ret0, ret1 1146 } 1147 1148 // DescribeTargetGroupsRequest indicates an expected call of DescribeTargetGroupsRequest 1149 func (mr *MockELBV2APIMockRecorder) DescribeTargetGroupsRequest(arg0 interface{}) *gomock.Call { 1150 mr.mock.ctrl.T.Helper() 1151 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetGroupsRequest", reflect.TypeOf((*MockELBV2API)(nil).DescribeTargetGroupsRequest), arg0) 1152 } 1153 1154 // DescribeTargetGroupsPages mocks base method 1155 func (m *MockELBV2API) DescribeTargetGroupsPages(arg0 *elbv2.DescribeTargetGroupsInput, arg1 func(*elbv2.DescribeTargetGroupsOutput, bool) bool) error { 1156 m.ctrl.T.Helper() 1157 ret := m.ctrl.Call(m, "DescribeTargetGroupsPages", arg0, arg1) 1158 ret0, _ := ret[0].(error) 1159 return ret0 1160 } 1161 1162 // DescribeTargetGroupsPages indicates an expected call of DescribeTargetGroupsPages 1163 func (mr *MockELBV2APIMockRecorder) DescribeTargetGroupsPages(arg0, arg1 interface{}) *gomock.Call { 1164 mr.mock.ctrl.T.Helper() 1165 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetGroupsPages", reflect.TypeOf((*MockELBV2API)(nil).DescribeTargetGroupsPages), arg0, arg1) 1166 } 1167 1168 // DescribeTargetGroupsPagesWithContext mocks base method 1169 func (m *MockELBV2API) DescribeTargetGroupsPagesWithContext(arg0 aws.Context, arg1 *elbv2.DescribeTargetGroupsInput, arg2 func(*elbv2.DescribeTargetGroupsOutput, bool) bool, arg3 ...request.Option) error { 1170 m.ctrl.T.Helper() 1171 varargs := []interface{}{arg0, arg1, arg2} 1172 for _, a := range arg3 { 1173 varargs = append(varargs, a) 1174 } 1175 ret := m.ctrl.Call(m, "DescribeTargetGroupsPagesWithContext", varargs...) 1176 ret0, _ := ret[0].(error) 1177 return ret0 1178 } 1179 1180 // DescribeTargetGroupsPagesWithContext indicates an expected call of DescribeTargetGroupsPagesWithContext 1181 func (mr *MockELBV2APIMockRecorder) DescribeTargetGroupsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 1182 mr.mock.ctrl.T.Helper() 1183 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 1184 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetGroupsPagesWithContext", reflect.TypeOf((*MockELBV2API)(nil).DescribeTargetGroupsPagesWithContext), varargs...) 1185 } 1186 1187 // DescribeTargetHealth mocks base method 1188 func (m *MockELBV2API) DescribeTargetHealth(arg0 *elbv2.DescribeTargetHealthInput) (*elbv2.DescribeTargetHealthOutput, error) { 1189 m.ctrl.T.Helper() 1190 ret := m.ctrl.Call(m, "DescribeTargetHealth", arg0) 1191 ret0, _ := ret[0].(*elbv2.DescribeTargetHealthOutput) 1192 ret1, _ := ret[1].(error) 1193 return ret0, ret1 1194 } 1195 1196 // DescribeTargetHealth indicates an expected call of DescribeTargetHealth 1197 func (mr *MockELBV2APIMockRecorder) DescribeTargetHealth(arg0 interface{}) *gomock.Call { 1198 mr.mock.ctrl.T.Helper() 1199 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetHealth", reflect.TypeOf((*MockELBV2API)(nil).DescribeTargetHealth), arg0) 1200 } 1201 1202 // DescribeTargetHealthWithContext mocks base method 1203 func (m *MockELBV2API) DescribeTargetHealthWithContext(arg0 aws.Context, arg1 *elbv2.DescribeTargetHealthInput, arg2 ...request.Option) (*elbv2.DescribeTargetHealthOutput, error) { 1204 m.ctrl.T.Helper() 1205 varargs := []interface{}{arg0, arg1} 1206 for _, a := range arg2 { 1207 varargs = append(varargs, a) 1208 } 1209 ret := m.ctrl.Call(m, "DescribeTargetHealthWithContext", varargs...) 1210 ret0, _ := ret[0].(*elbv2.DescribeTargetHealthOutput) 1211 ret1, _ := ret[1].(error) 1212 return ret0, ret1 1213 } 1214 1215 // DescribeTargetHealthWithContext indicates an expected call of DescribeTargetHealthWithContext 1216 func (mr *MockELBV2APIMockRecorder) DescribeTargetHealthWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1217 mr.mock.ctrl.T.Helper() 1218 varargs := append([]interface{}{arg0, arg1}, arg2...) 1219 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetHealthWithContext", reflect.TypeOf((*MockELBV2API)(nil).DescribeTargetHealthWithContext), varargs...) 1220 } 1221 1222 // DescribeTargetHealthRequest mocks base method 1223 func (m *MockELBV2API) DescribeTargetHealthRequest(arg0 *elbv2.DescribeTargetHealthInput) (*request.Request, *elbv2.DescribeTargetHealthOutput) { 1224 m.ctrl.T.Helper() 1225 ret := m.ctrl.Call(m, "DescribeTargetHealthRequest", arg0) 1226 ret0, _ := ret[0].(*request.Request) 1227 ret1, _ := ret[1].(*elbv2.DescribeTargetHealthOutput) 1228 return ret0, ret1 1229 } 1230 1231 // DescribeTargetHealthRequest indicates an expected call of DescribeTargetHealthRequest 1232 func (mr *MockELBV2APIMockRecorder) DescribeTargetHealthRequest(arg0 interface{}) *gomock.Call { 1233 mr.mock.ctrl.T.Helper() 1234 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetHealthRequest", reflect.TypeOf((*MockELBV2API)(nil).DescribeTargetHealthRequest), arg0) 1235 } 1236 1237 // ModifyListener mocks base method 1238 func (m *MockELBV2API) ModifyListener(arg0 *elbv2.ModifyListenerInput) (*elbv2.ModifyListenerOutput, error) { 1239 m.ctrl.T.Helper() 1240 ret := m.ctrl.Call(m, "ModifyListener", arg0) 1241 ret0, _ := ret[0].(*elbv2.ModifyListenerOutput) 1242 ret1, _ := ret[1].(error) 1243 return ret0, ret1 1244 } 1245 1246 // ModifyListener indicates an expected call of ModifyListener 1247 func (mr *MockELBV2APIMockRecorder) ModifyListener(arg0 interface{}) *gomock.Call { 1248 mr.mock.ctrl.T.Helper() 1249 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyListener", reflect.TypeOf((*MockELBV2API)(nil).ModifyListener), arg0) 1250 } 1251 1252 // ModifyListenerWithContext mocks base method 1253 func (m *MockELBV2API) ModifyListenerWithContext(arg0 aws.Context, arg1 *elbv2.ModifyListenerInput, arg2 ...request.Option) (*elbv2.ModifyListenerOutput, error) { 1254 m.ctrl.T.Helper() 1255 varargs := []interface{}{arg0, arg1} 1256 for _, a := range arg2 { 1257 varargs = append(varargs, a) 1258 } 1259 ret := m.ctrl.Call(m, "ModifyListenerWithContext", varargs...) 1260 ret0, _ := ret[0].(*elbv2.ModifyListenerOutput) 1261 ret1, _ := ret[1].(error) 1262 return ret0, ret1 1263 } 1264 1265 // ModifyListenerWithContext indicates an expected call of ModifyListenerWithContext 1266 func (mr *MockELBV2APIMockRecorder) ModifyListenerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1267 mr.mock.ctrl.T.Helper() 1268 varargs := append([]interface{}{arg0, arg1}, arg2...) 1269 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyListenerWithContext", reflect.TypeOf((*MockELBV2API)(nil).ModifyListenerWithContext), varargs...) 1270 } 1271 1272 // ModifyListenerRequest mocks base method 1273 func (m *MockELBV2API) ModifyListenerRequest(arg0 *elbv2.ModifyListenerInput) (*request.Request, *elbv2.ModifyListenerOutput) { 1274 m.ctrl.T.Helper() 1275 ret := m.ctrl.Call(m, "ModifyListenerRequest", arg0) 1276 ret0, _ := ret[0].(*request.Request) 1277 ret1, _ := ret[1].(*elbv2.ModifyListenerOutput) 1278 return ret0, ret1 1279 } 1280 1281 // ModifyListenerRequest indicates an expected call of ModifyListenerRequest 1282 func (mr *MockELBV2APIMockRecorder) ModifyListenerRequest(arg0 interface{}) *gomock.Call { 1283 mr.mock.ctrl.T.Helper() 1284 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyListenerRequest", reflect.TypeOf((*MockELBV2API)(nil).ModifyListenerRequest), arg0) 1285 } 1286 1287 // ModifyLoadBalancerAttributes mocks base method 1288 func (m *MockELBV2API) ModifyLoadBalancerAttributes(arg0 *elbv2.ModifyLoadBalancerAttributesInput) (*elbv2.ModifyLoadBalancerAttributesOutput, error) { 1289 m.ctrl.T.Helper() 1290 ret := m.ctrl.Call(m, "ModifyLoadBalancerAttributes", arg0) 1291 ret0, _ := ret[0].(*elbv2.ModifyLoadBalancerAttributesOutput) 1292 ret1, _ := ret[1].(error) 1293 return ret0, ret1 1294 } 1295 1296 // ModifyLoadBalancerAttributes indicates an expected call of ModifyLoadBalancerAttributes 1297 func (mr *MockELBV2APIMockRecorder) ModifyLoadBalancerAttributes(arg0 interface{}) *gomock.Call { 1298 mr.mock.ctrl.T.Helper() 1299 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyLoadBalancerAttributes", reflect.TypeOf((*MockELBV2API)(nil).ModifyLoadBalancerAttributes), arg0) 1300 } 1301 1302 // ModifyLoadBalancerAttributesWithContext mocks base method 1303 func (m *MockELBV2API) ModifyLoadBalancerAttributesWithContext(arg0 aws.Context, arg1 *elbv2.ModifyLoadBalancerAttributesInput, arg2 ...request.Option) (*elbv2.ModifyLoadBalancerAttributesOutput, error) { 1304 m.ctrl.T.Helper() 1305 varargs := []interface{}{arg0, arg1} 1306 for _, a := range arg2 { 1307 varargs = append(varargs, a) 1308 } 1309 ret := m.ctrl.Call(m, "ModifyLoadBalancerAttributesWithContext", varargs...) 1310 ret0, _ := ret[0].(*elbv2.ModifyLoadBalancerAttributesOutput) 1311 ret1, _ := ret[1].(error) 1312 return ret0, ret1 1313 } 1314 1315 // ModifyLoadBalancerAttributesWithContext indicates an expected call of ModifyLoadBalancerAttributesWithContext 1316 func (mr *MockELBV2APIMockRecorder) ModifyLoadBalancerAttributesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1317 mr.mock.ctrl.T.Helper() 1318 varargs := append([]interface{}{arg0, arg1}, arg2...) 1319 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyLoadBalancerAttributesWithContext", reflect.TypeOf((*MockELBV2API)(nil).ModifyLoadBalancerAttributesWithContext), varargs...) 1320 } 1321 1322 // ModifyLoadBalancerAttributesRequest mocks base method 1323 func (m *MockELBV2API) ModifyLoadBalancerAttributesRequest(arg0 *elbv2.ModifyLoadBalancerAttributesInput) (*request.Request, *elbv2.ModifyLoadBalancerAttributesOutput) { 1324 m.ctrl.T.Helper() 1325 ret := m.ctrl.Call(m, "ModifyLoadBalancerAttributesRequest", arg0) 1326 ret0, _ := ret[0].(*request.Request) 1327 ret1, _ := ret[1].(*elbv2.ModifyLoadBalancerAttributesOutput) 1328 return ret0, ret1 1329 } 1330 1331 // ModifyLoadBalancerAttributesRequest indicates an expected call of ModifyLoadBalancerAttributesRequest 1332 func (mr *MockELBV2APIMockRecorder) ModifyLoadBalancerAttributesRequest(arg0 interface{}) *gomock.Call { 1333 mr.mock.ctrl.T.Helper() 1334 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyLoadBalancerAttributesRequest", reflect.TypeOf((*MockELBV2API)(nil).ModifyLoadBalancerAttributesRequest), arg0) 1335 } 1336 1337 // ModifyRule mocks base method 1338 func (m *MockELBV2API) ModifyRule(arg0 *elbv2.ModifyRuleInput) (*elbv2.ModifyRuleOutput, error) { 1339 m.ctrl.T.Helper() 1340 ret := m.ctrl.Call(m, "ModifyRule", arg0) 1341 ret0, _ := ret[0].(*elbv2.ModifyRuleOutput) 1342 ret1, _ := ret[1].(error) 1343 return ret0, ret1 1344 } 1345 1346 // ModifyRule indicates an expected call of ModifyRule 1347 func (mr *MockELBV2APIMockRecorder) ModifyRule(arg0 interface{}) *gomock.Call { 1348 mr.mock.ctrl.T.Helper() 1349 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyRule", reflect.TypeOf((*MockELBV2API)(nil).ModifyRule), arg0) 1350 } 1351 1352 // ModifyRuleWithContext mocks base method 1353 func (m *MockELBV2API) ModifyRuleWithContext(arg0 aws.Context, arg1 *elbv2.ModifyRuleInput, arg2 ...request.Option) (*elbv2.ModifyRuleOutput, error) { 1354 m.ctrl.T.Helper() 1355 varargs := []interface{}{arg0, arg1} 1356 for _, a := range arg2 { 1357 varargs = append(varargs, a) 1358 } 1359 ret := m.ctrl.Call(m, "ModifyRuleWithContext", varargs...) 1360 ret0, _ := ret[0].(*elbv2.ModifyRuleOutput) 1361 ret1, _ := ret[1].(error) 1362 return ret0, ret1 1363 } 1364 1365 // ModifyRuleWithContext indicates an expected call of ModifyRuleWithContext 1366 func (mr *MockELBV2APIMockRecorder) ModifyRuleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1367 mr.mock.ctrl.T.Helper() 1368 varargs := append([]interface{}{arg0, arg1}, arg2...) 1369 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyRuleWithContext", reflect.TypeOf((*MockELBV2API)(nil).ModifyRuleWithContext), varargs...) 1370 } 1371 1372 // ModifyRuleRequest mocks base method 1373 func (m *MockELBV2API) ModifyRuleRequest(arg0 *elbv2.ModifyRuleInput) (*request.Request, *elbv2.ModifyRuleOutput) { 1374 m.ctrl.T.Helper() 1375 ret := m.ctrl.Call(m, "ModifyRuleRequest", arg0) 1376 ret0, _ := ret[0].(*request.Request) 1377 ret1, _ := ret[1].(*elbv2.ModifyRuleOutput) 1378 return ret0, ret1 1379 } 1380 1381 // ModifyRuleRequest indicates an expected call of ModifyRuleRequest 1382 func (mr *MockELBV2APIMockRecorder) ModifyRuleRequest(arg0 interface{}) *gomock.Call { 1383 mr.mock.ctrl.T.Helper() 1384 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyRuleRequest", reflect.TypeOf((*MockELBV2API)(nil).ModifyRuleRequest), arg0) 1385 } 1386 1387 // ModifyTargetGroup mocks base method 1388 func (m *MockELBV2API) ModifyTargetGroup(arg0 *elbv2.ModifyTargetGroupInput) (*elbv2.ModifyTargetGroupOutput, error) { 1389 m.ctrl.T.Helper() 1390 ret := m.ctrl.Call(m, "ModifyTargetGroup", arg0) 1391 ret0, _ := ret[0].(*elbv2.ModifyTargetGroupOutput) 1392 ret1, _ := ret[1].(error) 1393 return ret0, ret1 1394 } 1395 1396 // ModifyTargetGroup indicates an expected call of ModifyTargetGroup 1397 func (mr *MockELBV2APIMockRecorder) ModifyTargetGroup(arg0 interface{}) *gomock.Call { 1398 mr.mock.ctrl.T.Helper() 1399 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTargetGroup", reflect.TypeOf((*MockELBV2API)(nil).ModifyTargetGroup), arg0) 1400 } 1401 1402 // ModifyTargetGroupWithContext mocks base method 1403 func (m *MockELBV2API) ModifyTargetGroupWithContext(arg0 aws.Context, arg1 *elbv2.ModifyTargetGroupInput, arg2 ...request.Option) (*elbv2.ModifyTargetGroupOutput, error) { 1404 m.ctrl.T.Helper() 1405 varargs := []interface{}{arg0, arg1} 1406 for _, a := range arg2 { 1407 varargs = append(varargs, a) 1408 } 1409 ret := m.ctrl.Call(m, "ModifyTargetGroupWithContext", varargs...) 1410 ret0, _ := ret[0].(*elbv2.ModifyTargetGroupOutput) 1411 ret1, _ := ret[1].(error) 1412 return ret0, ret1 1413 } 1414 1415 // ModifyTargetGroupWithContext indicates an expected call of ModifyTargetGroupWithContext 1416 func (mr *MockELBV2APIMockRecorder) ModifyTargetGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1417 mr.mock.ctrl.T.Helper() 1418 varargs := append([]interface{}{arg0, arg1}, arg2...) 1419 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTargetGroupWithContext", reflect.TypeOf((*MockELBV2API)(nil).ModifyTargetGroupWithContext), varargs...) 1420 } 1421 1422 // ModifyTargetGroupRequest mocks base method 1423 func (m *MockELBV2API) ModifyTargetGroupRequest(arg0 *elbv2.ModifyTargetGroupInput) (*request.Request, *elbv2.ModifyTargetGroupOutput) { 1424 m.ctrl.T.Helper() 1425 ret := m.ctrl.Call(m, "ModifyTargetGroupRequest", arg0) 1426 ret0, _ := ret[0].(*request.Request) 1427 ret1, _ := ret[1].(*elbv2.ModifyTargetGroupOutput) 1428 return ret0, ret1 1429 } 1430 1431 // ModifyTargetGroupRequest indicates an expected call of ModifyTargetGroupRequest 1432 func (mr *MockELBV2APIMockRecorder) ModifyTargetGroupRequest(arg0 interface{}) *gomock.Call { 1433 mr.mock.ctrl.T.Helper() 1434 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTargetGroupRequest", reflect.TypeOf((*MockELBV2API)(nil).ModifyTargetGroupRequest), arg0) 1435 } 1436 1437 // ModifyTargetGroupAttributes mocks base method 1438 func (m *MockELBV2API) ModifyTargetGroupAttributes(arg0 *elbv2.ModifyTargetGroupAttributesInput) (*elbv2.ModifyTargetGroupAttributesOutput, error) { 1439 m.ctrl.T.Helper() 1440 ret := m.ctrl.Call(m, "ModifyTargetGroupAttributes", arg0) 1441 ret0, _ := ret[0].(*elbv2.ModifyTargetGroupAttributesOutput) 1442 ret1, _ := ret[1].(error) 1443 return ret0, ret1 1444 } 1445 1446 // ModifyTargetGroupAttributes indicates an expected call of ModifyTargetGroupAttributes 1447 func (mr *MockELBV2APIMockRecorder) ModifyTargetGroupAttributes(arg0 interface{}) *gomock.Call { 1448 mr.mock.ctrl.T.Helper() 1449 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTargetGroupAttributes", reflect.TypeOf((*MockELBV2API)(nil).ModifyTargetGroupAttributes), arg0) 1450 } 1451 1452 // ModifyTargetGroupAttributesWithContext mocks base method 1453 func (m *MockELBV2API) ModifyTargetGroupAttributesWithContext(arg0 aws.Context, arg1 *elbv2.ModifyTargetGroupAttributesInput, arg2 ...request.Option) (*elbv2.ModifyTargetGroupAttributesOutput, error) { 1454 m.ctrl.T.Helper() 1455 varargs := []interface{}{arg0, arg1} 1456 for _, a := range arg2 { 1457 varargs = append(varargs, a) 1458 } 1459 ret := m.ctrl.Call(m, "ModifyTargetGroupAttributesWithContext", varargs...) 1460 ret0, _ := ret[0].(*elbv2.ModifyTargetGroupAttributesOutput) 1461 ret1, _ := ret[1].(error) 1462 return ret0, ret1 1463 } 1464 1465 // ModifyTargetGroupAttributesWithContext indicates an expected call of ModifyTargetGroupAttributesWithContext 1466 func (mr *MockELBV2APIMockRecorder) ModifyTargetGroupAttributesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1467 mr.mock.ctrl.T.Helper() 1468 varargs := append([]interface{}{arg0, arg1}, arg2...) 1469 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTargetGroupAttributesWithContext", reflect.TypeOf((*MockELBV2API)(nil).ModifyTargetGroupAttributesWithContext), varargs...) 1470 } 1471 1472 // ModifyTargetGroupAttributesRequest mocks base method 1473 func (m *MockELBV2API) ModifyTargetGroupAttributesRequest(arg0 *elbv2.ModifyTargetGroupAttributesInput) (*request.Request, *elbv2.ModifyTargetGroupAttributesOutput) { 1474 m.ctrl.T.Helper() 1475 ret := m.ctrl.Call(m, "ModifyTargetGroupAttributesRequest", arg0) 1476 ret0, _ := ret[0].(*request.Request) 1477 ret1, _ := ret[1].(*elbv2.ModifyTargetGroupAttributesOutput) 1478 return ret0, ret1 1479 } 1480 1481 // ModifyTargetGroupAttributesRequest indicates an expected call of ModifyTargetGroupAttributesRequest 1482 func (mr *MockELBV2APIMockRecorder) ModifyTargetGroupAttributesRequest(arg0 interface{}) *gomock.Call { 1483 mr.mock.ctrl.T.Helper() 1484 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTargetGroupAttributesRequest", reflect.TypeOf((*MockELBV2API)(nil).ModifyTargetGroupAttributesRequest), arg0) 1485 } 1486 1487 // RegisterTargets mocks base method 1488 func (m *MockELBV2API) RegisterTargets(arg0 *elbv2.RegisterTargetsInput) (*elbv2.RegisterTargetsOutput, error) { 1489 m.ctrl.T.Helper() 1490 ret := m.ctrl.Call(m, "RegisterTargets", arg0) 1491 ret0, _ := ret[0].(*elbv2.RegisterTargetsOutput) 1492 ret1, _ := ret[1].(error) 1493 return ret0, ret1 1494 } 1495 1496 // RegisterTargets indicates an expected call of RegisterTargets 1497 func (mr *MockELBV2APIMockRecorder) RegisterTargets(arg0 interface{}) *gomock.Call { 1498 mr.mock.ctrl.T.Helper() 1499 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTargets", reflect.TypeOf((*MockELBV2API)(nil).RegisterTargets), arg0) 1500 } 1501 1502 // RegisterTargetsWithContext mocks base method 1503 func (m *MockELBV2API) RegisterTargetsWithContext(arg0 aws.Context, arg1 *elbv2.RegisterTargetsInput, arg2 ...request.Option) (*elbv2.RegisterTargetsOutput, error) { 1504 m.ctrl.T.Helper() 1505 varargs := []interface{}{arg0, arg1} 1506 for _, a := range arg2 { 1507 varargs = append(varargs, a) 1508 } 1509 ret := m.ctrl.Call(m, "RegisterTargetsWithContext", varargs...) 1510 ret0, _ := ret[0].(*elbv2.RegisterTargetsOutput) 1511 ret1, _ := ret[1].(error) 1512 return ret0, ret1 1513 } 1514 1515 // RegisterTargetsWithContext indicates an expected call of RegisterTargetsWithContext 1516 func (mr *MockELBV2APIMockRecorder) RegisterTargetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1517 mr.mock.ctrl.T.Helper() 1518 varargs := append([]interface{}{arg0, arg1}, arg2...) 1519 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTargetsWithContext", reflect.TypeOf((*MockELBV2API)(nil).RegisterTargetsWithContext), varargs...) 1520 } 1521 1522 // RegisterTargetsRequest mocks base method 1523 func (m *MockELBV2API) RegisterTargetsRequest(arg0 *elbv2.RegisterTargetsInput) (*request.Request, *elbv2.RegisterTargetsOutput) { 1524 m.ctrl.T.Helper() 1525 ret := m.ctrl.Call(m, "RegisterTargetsRequest", arg0) 1526 ret0, _ := ret[0].(*request.Request) 1527 ret1, _ := ret[1].(*elbv2.RegisterTargetsOutput) 1528 return ret0, ret1 1529 } 1530 1531 // RegisterTargetsRequest indicates an expected call of RegisterTargetsRequest 1532 func (mr *MockELBV2APIMockRecorder) RegisterTargetsRequest(arg0 interface{}) *gomock.Call { 1533 mr.mock.ctrl.T.Helper() 1534 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTargetsRequest", reflect.TypeOf((*MockELBV2API)(nil).RegisterTargetsRequest), arg0) 1535 } 1536 1537 // RemoveListenerCertificates mocks base method 1538 func (m *MockELBV2API) RemoveListenerCertificates(arg0 *elbv2.RemoveListenerCertificatesInput) (*elbv2.RemoveListenerCertificatesOutput, error) { 1539 m.ctrl.T.Helper() 1540 ret := m.ctrl.Call(m, "RemoveListenerCertificates", arg0) 1541 ret0, _ := ret[0].(*elbv2.RemoveListenerCertificatesOutput) 1542 ret1, _ := ret[1].(error) 1543 return ret0, ret1 1544 } 1545 1546 // RemoveListenerCertificates indicates an expected call of RemoveListenerCertificates 1547 func (mr *MockELBV2APIMockRecorder) RemoveListenerCertificates(arg0 interface{}) *gomock.Call { 1548 mr.mock.ctrl.T.Helper() 1549 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveListenerCertificates", reflect.TypeOf((*MockELBV2API)(nil).RemoveListenerCertificates), arg0) 1550 } 1551 1552 // RemoveListenerCertificatesWithContext mocks base method 1553 func (m *MockELBV2API) RemoveListenerCertificatesWithContext(arg0 aws.Context, arg1 *elbv2.RemoveListenerCertificatesInput, arg2 ...request.Option) (*elbv2.RemoveListenerCertificatesOutput, error) { 1554 m.ctrl.T.Helper() 1555 varargs := []interface{}{arg0, arg1} 1556 for _, a := range arg2 { 1557 varargs = append(varargs, a) 1558 } 1559 ret := m.ctrl.Call(m, "RemoveListenerCertificatesWithContext", varargs...) 1560 ret0, _ := ret[0].(*elbv2.RemoveListenerCertificatesOutput) 1561 ret1, _ := ret[1].(error) 1562 return ret0, ret1 1563 } 1564 1565 // RemoveListenerCertificatesWithContext indicates an expected call of RemoveListenerCertificatesWithContext 1566 func (mr *MockELBV2APIMockRecorder) RemoveListenerCertificatesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1567 mr.mock.ctrl.T.Helper() 1568 varargs := append([]interface{}{arg0, arg1}, arg2...) 1569 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveListenerCertificatesWithContext", reflect.TypeOf((*MockELBV2API)(nil).RemoveListenerCertificatesWithContext), varargs...) 1570 } 1571 1572 // RemoveListenerCertificatesRequest mocks base method 1573 func (m *MockELBV2API) RemoveListenerCertificatesRequest(arg0 *elbv2.RemoveListenerCertificatesInput) (*request.Request, *elbv2.RemoveListenerCertificatesOutput) { 1574 m.ctrl.T.Helper() 1575 ret := m.ctrl.Call(m, "RemoveListenerCertificatesRequest", arg0) 1576 ret0, _ := ret[0].(*request.Request) 1577 ret1, _ := ret[1].(*elbv2.RemoveListenerCertificatesOutput) 1578 return ret0, ret1 1579 } 1580 1581 // RemoveListenerCertificatesRequest indicates an expected call of RemoveListenerCertificatesRequest 1582 func (mr *MockELBV2APIMockRecorder) RemoveListenerCertificatesRequest(arg0 interface{}) *gomock.Call { 1583 mr.mock.ctrl.T.Helper() 1584 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveListenerCertificatesRequest", reflect.TypeOf((*MockELBV2API)(nil).RemoveListenerCertificatesRequest), arg0) 1585 } 1586 1587 // RemoveTags mocks base method 1588 func (m *MockELBV2API) RemoveTags(arg0 *elbv2.RemoveTagsInput) (*elbv2.RemoveTagsOutput, error) { 1589 m.ctrl.T.Helper() 1590 ret := m.ctrl.Call(m, "RemoveTags", arg0) 1591 ret0, _ := ret[0].(*elbv2.RemoveTagsOutput) 1592 ret1, _ := ret[1].(error) 1593 return ret0, ret1 1594 } 1595 1596 // RemoveTags indicates an expected call of RemoveTags 1597 func (mr *MockELBV2APIMockRecorder) RemoveTags(arg0 interface{}) *gomock.Call { 1598 mr.mock.ctrl.T.Helper() 1599 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTags", reflect.TypeOf((*MockELBV2API)(nil).RemoveTags), arg0) 1600 } 1601 1602 // RemoveTagsWithContext mocks base method 1603 func (m *MockELBV2API) RemoveTagsWithContext(arg0 aws.Context, arg1 *elbv2.RemoveTagsInput, arg2 ...request.Option) (*elbv2.RemoveTagsOutput, error) { 1604 m.ctrl.T.Helper() 1605 varargs := []interface{}{arg0, arg1} 1606 for _, a := range arg2 { 1607 varargs = append(varargs, a) 1608 } 1609 ret := m.ctrl.Call(m, "RemoveTagsWithContext", varargs...) 1610 ret0, _ := ret[0].(*elbv2.RemoveTagsOutput) 1611 ret1, _ := ret[1].(error) 1612 return ret0, ret1 1613 } 1614 1615 // RemoveTagsWithContext indicates an expected call of RemoveTagsWithContext 1616 func (mr *MockELBV2APIMockRecorder) RemoveTagsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1617 mr.mock.ctrl.T.Helper() 1618 varargs := append([]interface{}{arg0, arg1}, arg2...) 1619 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTagsWithContext", reflect.TypeOf((*MockELBV2API)(nil).RemoveTagsWithContext), varargs...) 1620 } 1621 1622 // RemoveTagsRequest mocks base method 1623 func (m *MockELBV2API) RemoveTagsRequest(arg0 *elbv2.RemoveTagsInput) (*request.Request, *elbv2.RemoveTagsOutput) { 1624 m.ctrl.T.Helper() 1625 ret := m.ctrl.Call(m, "RemoveTagsRequest", arg0) 1626 ret0, _ := ret[0].(*request.Request) 1627 ret1, _ := ret[1].(*elbv2.RemoveTagsOutput) 1628 return ret0, ret1 1629 } 1630 1631 // RemoveTagsRequest indicates an expected call of RemoveTagsRequest 1632 func (mr *MockELBV2APIMockRecorder) RemoveTagsRequest(arg0 interface{}) *gomock.Call { 1633 mr.mock.ctrl.T.Helper() 1634 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTagsRequest", reflect.TypeOf((*MockELBV2API)(nil).RemoveTagsRequest), arg0) 1635 } 1636 1637 // SetIpAddressType mocks base method 1638 func (m *MockELBV2API) SetIpAddressType(arg0 *elbv2.SetIpAddressTypeInput) (*elbv2.SetIpAddressTypeOutput, error) { 1639 m.ctrl.T.Helper() 1640 ret := m.ctrl.Call(m, "SetIpAddressType", arg0) 1641 ret0, _ := ret[0].(*elbv2.SetIpAddressTypeOutput) 1642 ret1, _ := ret[1].(error) 1643 return ret0, ret1 1644 } 1645 1646 // SetIpAddressType indicates an expected call of SetIpAddressType 1647 func (mr *MockELBV2APIMockRecorder) SetIpAddressType(arg0 interface{}) *gomock.Call { 1648 mr.mock.ctrl.T.Helper() 1649 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIpAddressType", reflect.TypeOf((*MockELBV2API)(nil).SetIpAddressType), arg0) 1650 } 1651 1652 // SetIpAddressTypeWithContext mocks base method 1653 func (m *MockELBV2API) SetIpAddressTypeWithContext(arg0 aws.Context, arg1 *elbv2.SetIpAddressTypeInput, arg2 ...request.Option) (*elbv2.SetIpAddressTypeOutput, error) { 1654 m.ctrl.T.Helper() 1655 varargs := []interface{}{arg0, arg1} 1656 for _, a := range arg2 { 1657 varargs = append(varargs, a) 1658 } 1659 ret := m.ctrl.Call(m, "SetIpAddressTypeWithContext", varargs...) 1660 ret0, _ := ret[0].(*elbv2.SetIpAddressTypeOutput) 1661 ret1, _ := ret[1].(error) 1662 return ret0, ret1 1663 } 1664 1665 // SetIpAddressTypeWithContext indicates an expected call of SetIpAddressTypeWithContext 1666 func (mr *MockELBV2APIMockRecorder) SetIpAddressTypeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1667 mr.mock.ctrl.T.Helper() 1668 varargs := append([]interface{}{arg0, arg1}, arg2...) 1669 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIpAddressTypeWithContext", reflect.TypeOf((*MockELBV2API)(nil).SetIpAddressTypeWithContext), varargs...) 1670 } 1671 1672 // SetIpAddressTypeRequest mocks base method 1673 func (m *MockELBV2API) SetIpAddressTypeRequest(arg0 *elbv2.SetIpAddressTypeInput) (*request.Request, *elbv2.SetIpAddressTypeOutput) { 1674 m.ctrl.T.Helper() 1675 ret := m.ctrl.Call(m, "SetIpAddressTypeRequest", arg0) 1676 ret0, _ := ret[0].(*request.Request) 1677 ret1, _ := ret[1].(*elbv2.SetIpAddressTypeOutput) 1678 return ret0, ret1 1679 } 1680 1681 // SetIpAddressTypeRequest indicates an expected call of SetIpAddressTypeRequest 1682 func (mr *MockELBV2APIMockRecorder) SetIpAddressTypeRequest(arg0 interface{}) *gomock.Call { 1683 mr.mock.ctrl.T.Helper() 1684 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIpAddressTypeRequest", reflect.TypeOf((*MockELBV2API)(nil).SetIpAddressTypeRequest), arg0) 1685 } 1686 1687 // SetRulePriorities mocks base method 1688 func (m *MockELBV2API) SetRulePriorities(arg0 *elbv2.SetRulePrioritiesInput) (*elbv2.SetRulePrioritiesOutput, error) { 1689 m.ctrl.T.Helper() 1690 ret := m.ctrl.Call(m, "SetRulePriorities", arg0) 1691 ret0, _ := ret[0].(*elbv2.SetRulePrioritiesOutput) 1692 ret1, _ := ret[1].(error) 1693 return ret0, ret1 1694 } 1695 1696 // SetRulePriorities indicates an expected call of SetRulePriorities 1697 func (mr *MockELBV2APIMockRecorder) SetRulePriorities(arg0 interface{}) *gomock.Call { 1698 mr.mock.ctrl.T.Helper() 1699 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRulePriorities", reflect.TypeOf((*MockELBV2API)(nil).SetRulePriorities), arg0) 1700 } 1701 1702 // SetRulePrioritiesWithContext mocks base method 1703 func (m *MockELBV2API) SetRulePrioritiesWithContext(arg0 aws.Context, arg1 *elbv2.SetRulePrioritiesInput, arg2 ...request.Option) (*elbv2.SetRulePrioritiesOutput, error) { 1704 m.ctrl.T.Helper() 1705 varargs := []interface{}{arg0, arg1} 1706 for _, a := range arg2 { 1707 varargs = append(varargs, a) 1708 } 1709 ret := m.ctrl.Call(m, "SetRulePrioritiesWithContext", varargs...) 1710 ret0, _ := ret[0].(*elbv2.SetRulePrioritiesOutput) 1711 ret1, _ := ret[1].(error) 1712 return ret0, ret1 1713 } 1714 1715 // SetRulePrioritiesWithContext indicates an expected call of SetRulePrioritiesWithContext 1716 func (mr *MockELBV2APIMockRecorder) SetRulePrioritiesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1717 mr.mock.ctrl.T.Helper() 1718 varargs := append([]interface{}{arg0, arg1}, arg2...) 1719 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRulePrioritiesWithContext", reflect.TypeOf((*MockELBV2API)(nil).SetRulePrioritiesWithContext), varargs...) 1720 } 1721 1722 // SetRulePrioritiesRequest mocks base method 1723 func (m *MockELBV2API) SetRulePrioritiesRequest(arg0 *elbv2.SetRulePrioritiesInput) (*request.Request, *elbv2.SetRulePrioritiesOutput) { 1724 m.ctrl.T.Helper() 1725 ret := m.ctrl.Call(m, "SetRulePrioritiesRequest", arg0) 1726 ret0, _ := ret[0].(*request.Request) 1727 ret1, _ := ret[1].(*elbv2.SetRulePrioritiesOutput) 1728 return ret0, ret1 1729 } 1730 1731 // SetRulePrioritiesRequest indicates an expected call of SetRulePrioritiesRequest 1732 func (mr *MockELBV2APIMockRecorder) SetRulePrioritiesRequest(arg0 interface{}) *gomock.Call { 1733 mr.mock.ctrl.T.Helper() 1734 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRulePrioritiesRequest", reflect.TypeOf((*MockELBV2API)(nil).SetRulePrioritiesRequest), arg0) 1735 } 1736 1737 // SetSecurityGroups mocks base method 1738 func (m *MockELBV2API) SetSecurityGroups(arg0 *elbv2.SetSecurityGroupsInput) (*elbv2.SetSecurityGroupsOutput, error) { 1739 m.ctrl.T.Helper() 1740 ret := m.ctrl.Call(m, "SetSecurityGroups", arg0) 1741 ret0, _ := ret[0].(*elbv2.SetSecurityGroupsOutput) 1742 ret1, _ := ret[1].(error) 1743 return ret0, ret1 1744 } 1745 1746 // SetSecurityGroups indicates an expected call of SetSecurityGroups 1747 func (mr *MockELBV2APIMockRecorder) SetSecurityGroups(arg0 interface{}) *gomock.Call { 1748 mr.mock.ctrl.T.Helper() 1749 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSecurityGroups", reflect.TypeOf((*MockELBV2API)(nil).SetSecurityGroups), arg0) 1750 } 1751 1752 // SetSecurityGroupsWithContext mocks base method 1753 func (m *MockELBV2API) SetSecurityGroupsWithContext(arg0 aws.Context, arg1 *elbv2.SetSecurityGroupsInput, arg2 ...request.Option) (*elbv2.SetSecurityGroupsOutput, error) { 1754 m.ctrl.T.Helper() 1755 varargs := []interface{}{arg0, arg1} 1756 for _, a := range arg2 { 1757 varargs = append(varargs, a) 1758 } 1759 ret := m.ctrl.Call(m, "SetSecurityGroupsWithContext", varargs...) 1760 ret0, _ := ret[0].(*elbv2.SetSecurityGroupsOutput) 1761 ret1, _ := ret[1].(error) 1762 return ret0, ret1 1763 } 1764 1765 // SetSecurityGroupsWithContext indicates an expected call of SetSecurityGroupsWithContext 1766 func (mr *MockELBV2APIMockRecorder) SetSecurityGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1767 mr.mock.ctrl.T.Helper() 1768 varargs := append([]interface{}{arg0, arg1}, arg2...) 1769 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSecurityGroupsWithContext", reflect.TypeOf((*MockELBV2API)(nil).SetSecurityGroupsWithContext), varargs...) 1770 } 1771 1772 // SetSecurityGroupsRequest mocks base method 1773 func (m *MockELBV2API) SetSecurityGroupsRequest(arg0 *elbv2.SetSecurityGroupsInput) (*request.Request, *elbv2.SetSecurityGroupsOutput) { 1774 m.ctrl.T.Helper() 1775 ret := m.ctrl.Call(m, "SetSecurityGroupsRequest", arg0) 1776 ret0, _ := ret[0].(*request.Request) 1777 ret1, _ := ret[1].(*elbv2.SetSecurityGroupsOutput) 1778 return ret0, ret1 1779 } 1780 1781 // SetSecurityGroupsRequest indicates an expected call of SetSecurityGroupsRequest 1782 func (mr *MockELBV2APIMockRecorder) SetSecurityGroupsRequest(arg0 interface{}) *gomock.Call { 1783 mr.mock.ctrl.T.Helper() 1784 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSecurityGroupsRequest", reflect.TypeOf((*MockELBV2API)(nil).SetSecurityGroupsRequest), arg0) 1785 } 1786 1787 // SetSubnets mocks base method 1788 func (m *MockELBV2API) SetSubnets(arg0 *elbv2.SetSubnetsInput) (*elbv2.SetSubnetsOutput, error) { 1789 m.ctrl.T.Helper() 1790 ret := m.ctrl.Call(m, "SetSubnets", arg0) 1791 ret0, _ := ret[0].(*elbv2.SetSubnetsOutput) 1792 ret1, _ := ret[1].(error) 1793 return ret0, ret1 1794 } 1795 1796 // SetSubnets indicates an expected call of SetSubnets 1797 func (mr *MockELBV2APIMockRecorder) SetSubnets(arg0 interface{}) *gomock.Call { 1798 mr.mock.ctrl.T.Helper() 1799 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSubnets", reflect.TypeOf((*MockELBV2API)(nil).SetSubnets), arg0) 1800 } 1801 1802 // SetSubnetsWithContext mocks base method 1803 func (m *MockELBV2API) SetSubnetsWithContext(arg0 aws.Context, arg1 *elbv2.SetSubnetsInput, arg2 ...request.Option) (*elbv2.SetSubnetsOutput, error) { 1804 m.ctrl.T.Helper() 1805 varargs := []interface{}{arg0, arg1} 1806 for _, a := range arg2 { 1807 varargs = append(varargs, a) 1808 } 1809 ret := m.ctrl.Call(m, "SetSubnetsWithContext", varargs...) 1810 ret0, _ := ret[0].(*elbv2.SetSubnetsOutput) 1811 ret1, _ := ret[1].(error) 1812 return ret0, ret1 1813 } 1814 1815 // SetSubnetsWithContext indicates an expected call of SetSubnetsWithContext 1816 func (mr *MockELBV2APIMockRecorder) SetSubnetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1817 mr.mock.ctrl.T.Helper() 1818 varargs := append([]interface{}{arg0, arg1}, arg2...) 1819 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSubnetsWithContext", reflect.TypeOf((*MockELBV2API)(nil).SetSubnetsWithContext), varargs...) 1820 } 1821 1822 // SetSubnetsRequest mocks base method 1823 func (m *MockELBV2API) SetSubnetsRequest(arg0 *elbv2.SetSubnetsInput) (*request.Request, *elbv2.SetSubnetsOutput) { 1824 m.ctrl.T.Helper() 1825 ret := m.ctrl.Call(m, "SetSubnetsRequest", arg0) 1826 ret0, _ := ret[0].(*request.Request) 1827 ret1, _ := ret[1].(*elbv2.SetSubnetsOutput) 1828 return ret0, ret1 1829 } 1830 1831 // SetSubnetsRequest indicates an expected call of SetSubnetsRequest 1832 func (mr *MockELBV2APIMockRecorder) SetSubnetsRequest(arg0 interface{}) *gomock.Call { 1833 mr.mock.ctrl.T.Helper() 1834 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSubnetsRequest", reflect.TypeOf((*MockELBV2API)(nil).SetSubnetsRequest), arg0) 1835 } 1836 1837 // WaitUntilLoadBalancerAvailable mocks base method 1838 func (m *MockELBV2API) WaitUntilLoadBalancerAvailable(arg0 *elbv2.DescribeLoadBalancersInput) error { 1839 m.ctrl.T.Helper() 1840 ret := m.ctrl.Call(m, "WaitUntilLoadBalancerAvailable", arg0) 1841 ret0, _ := ret[0].(error) 1842 return ret0 1843 } 1844 1845 // WaitUntilLoadBalancerAvailable indicates an expected call of WaitUntilLoadBalancerAvailable 1846 func (mr *MockELBV2APIMockRecorder) WaitUntilLoadBalancerAvailable(arg0 interface{}) *gomock.Call { 1847 mr.mock.ctrl.T.Helper() 1848 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilLoadBalancerAvailable", reflect.TypeOf((*MockELBV2API)(nil).WaitUntilLoadBalancerAvailable), arg0) 1849 } 1850 1851 // WaitUntilLoadBalancerAvailableWithContext mocks base method 1852 func (m *MockELBV2API) WaitUntilLoadBalancerAvailableWithContext(arg0 aws.Context, arg1 *elbv2.DescribeLoadBalancersInput, arg2 ...request.WaiterOption) error { 1853 m.ctrl.T.Helper() 1854 varargs := []interface{}{arg0, arg1} 1855 for _, a := range arg2 { 1856 varargs = append(varargs, a) 1857 } 1858 ret := m.ctrl.Call(m, "WaitUntilLoadBalancerAvailableWithContext", varargs...) 1859 ret0, _ := ret[0].(error) 1860 return ret0 1861 } 1862 1863 // WaitUntilLoadBalancerAvailableWithContext indicates an expected call of WaitUntilLoadBalancerAvailableWithContext 1864 func (mr *MockELBV2APIMockRecorder) WaitUntilLoadBalancerAvailableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1865 mr.mock.ctrl.T.Helper() 1866 varargs := append([]interface{}{arg0, arg1}, arg2...) 1867 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilLoadBalancerAvailableWithContext", reflect.TypeOf((*MockELBV2API)(nil).WaitUntilLoadBalancerAvailableWithContext), varargs...) 1868 } 1869 1870 // WaitUntilLoadBalancerExists mocks base method 1871 func (m *MockELBV2API) WaitUntilLoadBalancerExists(arg0 *elbv2.DescribeLoadBalancersInput) error { 1872 m.ctrl.T.Helper() 1873 ret := m.ctrl.Call(m, "WaitUntilLoadBalancerExists", arg0) 1874 ret0, _ := ret[0].(error) 1875 return ret0 1876 } 1877 1878 // WaitUntilLoadBalancerExists indicates an expected call of WaitUntilLoadBalancerExists 1879 func (mr *MockELBV2APIMockRecorder) WaitUntilLoadBalancerExists(arg0 interface{}) *gomock.Call { 1880 mr.mock.ctrl.T.Helper() 1881 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilLoadBalancerExists", reflect.TypeOf((*MockELBV2API)(nil).WaitUntilLoadBalancerExists), arg0) 1882 } 1883 1884 // WaitUntilLoadBalancerExistsWithContext mocks base method 1885 func (m *MockELBV2API) WaitUntilLoadBalancerExistsWithContext(arg0 aws.Context, arg1 *elbv2.DescribeLoadBalancersInput, arg2 ...request.WaiterOption) error { 1886 m.ctrl.T.Helper() 1887 varargs := []interface{}{arg0, arg1} 1888 for _, a := range arg2 { 1889 varargs = append(varargs, a) 1890 } 1891 ret := m.ctrl.Call(m, "WaitUntilLoadBalancerExistsWithContext", varargs...) 1892 ret0, _ := ret[0].(error) 1893 return ret0 1894 } 1895 1896 // WaitUntilLoadBalancerExistsWithContext indicates an expected call of WaitUntilLoadBalancerExistsWithContext 1897 func (mr *MockELBV2APIMockRecorder) WaitUntilLoadBalancerExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1898 mr.mock.ctrl.T.Helper() 1899 varargs := append([]interface{}{arg0, arg1}, arg2...) 1900 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilLoadBalancerExistsWithContext", reflect.TypeOf((*MockELBV2API)(nil).WaitUntilLoadBalancerExistsWithContext), varargs...) 1901 } 1902 1903 // WaitUntilLoadBalancersDeleted mocks base method 1904 func (m *MockELBV2API) WaitUntilLoadBalancersDeleted(arg0 *elbv2.DescribeLoadBalancersInput) error { 1905 m.ctrl.T.Helper() 1906 ret := m.ctrl.Call(m, "WaitUntilLoadBalancersDeleted", arg0) 1907 ret0, _ := ret[0].(error) 1908 return ret0 1909 } 1910 1911 // WaitUntilLoadBalancersDeleted indicates an expected call of WaitUntilLoadBalancersDeleted 1912 func (mr *MockELBV2APIMockRecorder) WaitUntilLoadBalancersDeleted(arg0 interface{}) *gomock.Call { 1913 mr.mock.ctrl.T.Helper() 1914 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilLoadBalancersDeleted", reflect.TypeOf((*MockELBV2API)(nil).WaitUntilLoadBalancersDeleted), arg0) 1915 } 1916 1917 // WaitUntilLoadBalancersDeletedWithContext mocks base method 1918 func (m *MockELBV2API) WaitUntilLoadBalancersDeletedWithContext(arg0 aws.Context, arg1 *elbv2.DescribeLoadBalancersInput, arg2 ...request.WaiterOption) error { 1919 m.ctrl.T.Helper() 1920 varargs := []interface{}{arg0, arg1} 1921 for _, a := range arg2 { 1922 varargs = append(varargs, a) 1923 } 1924 ret := m.ctrl.Call(m, "WaitUntilLoadBalancersDeletedWithContext", varargs...) 1925 ret0, _ := ret[0].(error) 1926 return ret0 1927 } 1928 1929 // WaitUntilLoadBalancersDeletedWithContext indicates an expected call of WaitUntilLoadBalancersDeletedWithContext 1930 func (mr *MockELBV2APIMockRecorder) WaitUntilLoadBalancersDeletedWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1931 mr.mock.ctrl.T.Helper() 1932 varargs := append([]interface{}{arg0, arg1}, arg2...) 1933 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilLoadBalancersDeletedWithContext", reflect.TypeOf((*MockELBV2API)(nil).WaitUntilLoadBalancersDeletedWithContext), varargs...) 1934 } 1935 1936 // WaitUntilTargetDeregistered mocks base method 1937 func (m *MockELBV2API) WaitUntilTargetDeregistered(arg0 *elbv2.DescribeTargetHealthInput) error { 1938 m.ctrl.T.Helper() 1939 ret := m.ctrl.Call(m, "WaitUntilTargetDeregistered", arg0) 1940 ret0, _ := ret[0].(error) 1941 return ret0 1942 } 1943 1944 // WaitUntilTargetDeregistered indicates an expected call of WaitUntilTargetDeregistered 1945 func (mr *MockELBV2APIMockRecorder) WaitUntilTargetDeregistered(arg0 interface{}) *gomock.Call { 1946 mr.mock.ctrl.T.Helper() 1947 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilTargetDeregistered", reflect.TypeOf((*MockELBV2API)(nil).WaitUntilTargetDeregistered), arg0) 1948 } 1949 1950 // WaitUntilTargetDeregisteredWithContext mocks base method 1951 func (m *MockELBV2API) WaitUntilTargetDeregisteredWithContext(arg0 aws.Context, arg1 *elbv2.DescribeTargetHealthInput, arg2 ...request.WaiterOption) error { 1952 m.ctrl.T.Helper() 1953 varargs := []interface{}{arg0, arg1} 1954 for _, a := range arg2 { 1955 varargs = append(varargs, a) 1956 } 1957 ret := m.ctrl.Call(m, "WaitUntilTargetDeregisteredWithContext", varargs...) 1958 ret0, _ := ret[0].(error) 1959 return ret0 1960 } 1961 1962 // WaitUntilTargetDeregisteredWithContext indicates an expected call of WaitUntilTargetDeregisteredWithContext 1963 func (mr *MockELBV2APIMockRecorder) WaitUntilTargetDeregisteredWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1964 mr.mock.ctrl.T.Helper() 1965 varargs := append([]interface{}{arg0, arg1}, arg2...) 1966 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilTargetDeregisteredWithContext", reflect.TypeOf((*MockELBV2API)(nil).WaitUntilTargetDeregisteredWithContext), varargs...) 1967 } 1968 1969 // WaitUntilTargetInService mocks base method 1970 func (m *MockELBV2API) WaitUntilTargetInService(arg0 *elbv2.DescribeTargetHealthInput) error { 1971 m.ctrl.T.Helper() 1972 ret := m.ctrl.Call(m, "WaitUntilTargetInService", arg0) 1973 ret0, _ := ret[0].(error) 1974 return ret0 1975 } 1976 1977 // WaitUntilTargetInService indicates an expected call of WaitUntilTargetInService 1978 func (mr *MockELBV2APIMockRecorder) WaitUntilTargetInService(arg0 interface{}) *gomock.Call { 1979 mr.mock.ctrl.T.Helper() 1980 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilTargetInService", reflect.TypeOf((*MockELBV2API)(nil).WaitUntilTargetInService), arg0) 1981 } 1982 1983 // WaitUntilTargetInServiceWithContext mocks base method 1984 func (m *MockELBV2API) WaitUntilTargetInServiceWithContext(arg0 aws.Context, arg1 *elbv2.DescribeTargetHealthInput, arg2 ...request.WaiterOption) error { 1985 m.ctrl.T.Helper() 1986 varargs := []interface{}{arg0, arg1} 1987 for _, a := range arg2 { 1988 varargs = append(varargs, a) 1989 } 1990 ret := m.ctrl.Call(m, "WaitUntilTargetInServiceWithContext", varargs...) 1991 ret0, _ := ret[0].(error) 1992 return ret0 1993 } 1994 1995 // WaitUntilTargetInServiceWithContext indicates an expected call of WaitUntilTargetInServiceWithContext 1996 func (mr *MockELBV2APIMockRecorder) WaitUntilTargetInServiceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1997 mr.mock.ctrl.T.Helper() 1998 varargs := append([]interface{}{arg0, arg1}, arg2...) 1999 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilTargetInServiceWithContext", reflect.TypeOf((*MockELBV2API)(nil).WaitUntilTargetInServiceWithContext), varargs...) 2000 }