github.com/jenkins-x/jx/v2@v2.1.155/pkg/helm/mocks/helmer.go (about) 1 // Code generated by pegomock. DO NOT EDIT. 2 // Source: github.com/jenkins-x/jx/v2/pkg/helm (interfaces: Helmer) 3 4 package helm_test 5 6 import ( 7 "reflect" 8 "time" 9 10 helm "github.com/jenkins-x/jx/v2/pkg/helm" 11 pegomock "github.com/petergtz/pegomock" 12 ) 13 14 type MockHelmer struct { 15 fail func(message string, callerSkip ...int) 16 } 17 18 func NewMockHelmer(options ...pegomock.Option) *MockHelmer { 19 mock := &MockHelmer{} 20 for _, option := range options { 21 option.Apply(mock) 22 } 23 return mock 24 } 25 26 func (mock *MockHelmer) SetFailHandler(fh pegomock.FailHandler) { mock.fail = fh } 27 func (mock *MockHelmer) FailHandler() pegomock.FailHandler { return mock.fail } 28 29 func (mock *MockHelmer) AddRepo(_param0 string, _param1 string, _param2 string, _param3 string) error { 30 if mock == nil { 31 panic("mock must not be nil. Use myMock := NewMockHelmer().") 32 } 33 params := []pegomock.Param{_param0, _param1, _param2, _param3} 34 result := pegomock.GetGenericMockFrom(mock).Invoke("AddRepo", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()}) 35 var ret0 error 36 if len(result) != 0 { 37 if result[0] != nil { 38 ret0 = result[0].(error) 39 } 40 } 41 return ret0 42 } 43 44 func (mock *MockHelmer) BuildDependency() error { 45 if mock == nil { 46 panic("mock must not be nil. Use myMock := NewMockHelmer().") 47 } 48 params := []pegomock.Param{} 49 result := pegomock.GetGenericMockFrom(mock).Invoke("BuildDependency", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()}) 50 var ret0 error 51 if len(result) != 0 { 52 if result[0] != nil { 53 ret0 = result[0].(error) 54 } 55 } 56 return ret0 57 } 58 59 func (mock *MockHelmer) DecryptSecrets(_param0 string) error { 60 if mock == nil { 61 panic("mock must not be nil. Use myMock := NewMockHelmer().") 62 } 63 params := []pegomock.Param{_param0} 64 result := pegomock.GetGenericMockFrom(mock).Invoke("DecryptSecrets", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()}) 65 var ret0 error 66 if len(result) != 0 { 67 if result[0] != nil { 68 ret0 = result[0].(error) 69 } 70 } 71 return ret0 72 } 73 74 func (mock *MockHelmer) DeleteRelease(_param0 string, _param1 string, _param2 bool) error { 75 if mock == nil { 76 panic("mock must not be nil. Use myMock := NewMockHelmer().") 77 } 78 params := []pegomock.Param{_param0, _param1, _param2} 79 result := pegomock.GetGenericMockFrom(mock).Invoke("DeleteRelease", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()}) 80 var ret0 error 81 if len(result) != 0 { 82 if result[0] != nil { 83 ret0 = result[0].(error) 84 } 85 } 86 return ret0 87 } 88 89 func (mock *MockHelmer) Env() map[string]string { 90 if mock == nil { 91 panic("mock must not be nil. Use myMock := NewMockHelmer().") 92 } 93 params := []pegomock.Param{} 94 result := pegomock.GetGenericMockFrom(mock).Invoke("Env", params, []reflect.Type{reflect.TypeOf((*map[string]string)(nil)).Elem()}) 95 var ret0 map[string]string 96 if len(result) != 0 { 97 if result[0] != nil { 98 ret0 = result[0].(map[string]string) 99 } 100 } 101 return ret0 102 } 103 104 func (mock *MockHelmer) FetchChart(_param0 string, _param1 string, _param2 bool, _param3 string, _param4 string, _param5 string, _param6 string) error { 105 if mock == nil { 106 panic("mock must not be nil. Use myMock := NewMockHelmer().") 107 } 108 params := []pegomock.Param{_param0, _param1, _param2, _param3, _param4, _param5, _param6} 109 result := pegomock.GetGenericMockFrom(mock).Invoke("FetchChart", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()}) 110 var ret0 error 111 if len(result) != 0 { 112 if result[0] != nil { 113 ret0 = result[0].(error) 114 } 115 } 116 return ret0 117 } 118 119 func (mock *MockHelmer) FindChart() (string, error) { 120 if mock == nil { 121 panic("mock must not be nil. Use myMock := NewMockHelmer().") 122 } 123 params := []pegomock.Param{} 124 result := pegomock.GetGenericMockFrom(mock).Invoke("FindChart", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()}) 125 var ret0 string 126 var ret1 error 127 if len(result) != 0 { 128 if result[0] != nil { 129 ret0 = result[0].(string) 130 } 131 if result[1] != nil { 132 ret1 = result[1].(error) 133 } 134 } 135 return ret0, ret1 136 } 137 138 func (mock *MockHelmer) HelmBinary() string { 139 if mock == nil { 140 panic("mock must not be nil. Use myMock := NewMockHelmer().") 141 } 142 params := []pegomock.Param{} 143 result := pegomock.GetGenericMockFrom(mock).Invoke("HelmBinary", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem()}) 144 var ret0 string 145 if len(result) != 0 { 146 if result[0] != nil { 147 ret0 = result[0].(string) 148 } 149 } 150 return ret0 151 } 152 153 func (mock *MockHelmer) Init(_param0 bool, _param1 string, _param2 string, _param3 bool) error { 154 if mock == nil { 155 panic("mock must not be nil. Use myMock := NewMockHelmer().") 156 } 157 params := []pegomock.Param{_param0, _param1, _param2, _param3} 158 result := pegomock.GetGenericMockFrom(mock).Invoke("Init", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()}) 159 var ret0 error 160 if len(result) != 0 { 161 if result[0] != nil { 162 ret0 = result[0].(error) 163 } 164 } 165 return ret0 166 } 167 168 func (mock *MockHelmer) InstallChart(_param0 string, _param1 string, _param2 string, _param3 string, _param4 int, _param5 []string, _param6 []string, _param7 []string, _param8 string, _param9 string, _param10 string) error { 169 if mock == nil { 170 panic("mock must not be nil. Use myMock := NewMockHelmer().") 171 } 172 params := []pegomock.Param{_param0, _param1, _param2, _param3, _param4, _param5, _param6, _param7, _param8, _param9, _param10} 173 result := pegomock.GetGenericMockFrom(mock).Invoke("InstallChart", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()}) 174 var ret0 error 175 if len(result) != 0 { 176 if result[0] != nil { 177 ret0 = result[0].(error) 178 } 179 } 180 return ret0 181 } 182 183 func (mock *MockHelmer) IsRepoMissing(_param0 string) (bool, string, error) { 184 if mock == nil { 185 panic("mock must not be nil. Use myMock := NewMockHelmer().") 186 } 187 params := []pegomock.Param{_param0} 188 result := pegomock.GetGenericMockFrom(mock).Invoke("IsRepoMissing", params, []reflect.Type{reflect.TypeOf((*bool)(nil)).Elem(), reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()}) 189 var ret0 bool 190 var ret1 string 191 var ret2 error 192 if len(result) != 0 { 193 if result[0] != nil { 194 ret0 = result[0].(bool) 195 } 196 if result[1] != nil { 197 ret1 = result[1].(string) 198 } 199 if result[2] != nil { 200 ret2 = result[2].(error) 201 } 202 } 203 return ret0, ret1, ret2 204 } 205 206 func (mock *MockHelmer) Lint(_param0 []string) (string, error) { 207 if mock == nil { 208 panic("mock must not be nil. Use myMock := NewMockHelmer().") 209 } 210 params := []pegomock.Param{_param0} 211 result := pegomock.GetGenericMockFrom(mock).Invoke("Lint", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()}) 212 var ret0 string 213 var ret1 error 214 if len(result) != 0 { 215 if result[0] != nil { 216 ret0 = result[0].(string) 217 } 218 if result[1] != nil { 219 ret1 = result[1].(error) 220 } 221 } 222 return ret0, ret1 223 } 224 225 func (mock *MockHelmer) ListReleases(_param0 string) (map[string]helm.ReleaseSummary, []string, error) { 226 if mock == nil { 227 panic("mock must not be nil. Use myMock := NewMockHelmer().") 228 } 229 params := []pegomock.Param{_param0} 230 result := pegomock.GetGenericMockFrom(mock).Invoke("ListReleases", params, []reflect.Type{reflect.TypeOf((*map[string]helm.ReleaseSummary)(nil)).Elem(), reflect.TypeOf((*[]string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()}) 231 var ret0 map[string]helm.ReleaseSummary 232 var ret1 []string 233 var ret2 error 234 if len(result) != 0 { 235 if result[0] != nil { 236 ret0 = result[0].(map[string]helm.ReleaseSummary) 237 } 238 if result[1] != nil { 239 ret1 = result[1].([]string) 240 } 241 if result[2] != nil { 242 ret2 = result[2].(error) 243 } 244 } 245 return ret0, ret1, ret2 246 } 247 248 func (mock *MockHelmer) ListRepos() (map[string]string, error) { 249 if mock == nil { 250 panic("mock must not be nil. Use myMock := NewMockHelmer().") 251 } 252 params := []pegomock.Param{} 253 result := pegomock.GetGenericMockFrom(mock).Invoke("ListRepos", params, []reflect.Type{reflect.TypeOf((*map[string]string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()}) 254 var ret0 map[string]string 255 var ret1 error 256 if len(result) != 0 { 257 if result[0] != nil { 258 ret0 = result[0].(map[string]string) 259 } 260 if result[1] != nil { 261 ret1 = result[1].(error) 262 } 263 } 264 return ret0, ret1 265 } 266 267 func (mock *MockHelmer) PackageChart() error { 268 if mock == nil { 269 panic("mock must not be nil. Use myMock := NewMockHelmer().") 270 } 271 params := []pegomock.Param{} 272 result := pegomock.GetGenericMockFrom(mock).Invoke("PackageChart", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()}) 273 var ret0 error 274 if len(result) != 0 { 275 if result[0] != nil { 276 ret0 = result[0].(error) 277 } 278 } 279 return ret0 280 } 281 282 func (mock *MockHelmer) RemoveRepo(_param0 string) error { 283 if mock == nil { 284 panic("mock must not be nil. Use myMock := NewMockHelmer().") 285 } 286 params := []pegomock.Param{_param0} 287 result := pegomock.GetGenericMockFrom(mock).Invoke("RemoveRepo", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()}) 288 var ret0 error 289 if len(result) != 0 { 290 if result[0] != nil { 291 ret0 = result[0].(error) 292 } 293 } 294 return ret0 295 } 296 297 func (mock *MockHelmer) RemoveRequirementsLock() error { 298 if mock == nil { 299 panic("mock must not be nil. Use myMock := NewMockHelmer().") 300 } 301 params := []pegomock.Param{} 302 result := pegomock.GetGenericMockFrom(mock).Invoke("RemoveRequirementsLock", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()}) 303 var ret0 error 304 if len(result) != 0 { 305 if result[0] != nil { 306 ret0 = result[0].(error) 307 } 308 } 309 return ret0 310 } 311 312 func (mock *MockHelmer) SearchCharts(_param0 string, _param1 bool) ([]helm.ChartSummary, error) { 313 if mock == nil { 314 panic("mock must not be nil. Use myMock := NewMockHelmer().") 315 } 316 params := []pegomock.Param{_param0, _param1} 317 result := pegomock.GetGenericMockFrom(mock).Invoke("SearchCharts", params, []reflect.Type{reflect.TypeOf((*[]helm.ChartSummary)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()}) 318 var ret0 []helm.ChartSummary 319 var ret1 error 320 if len(result) != 0 { 321 if result[0] != nil { 322 ret0 = result[0].([]helm.ChartSummary) 323 } 324 if result[1] != nil { 325 ret1 = result[1].(error) 326 } 327 } 328 return ret0, ret1 329 } 330 331 func (mock *MockHelmer) SetCWD(_param0 string) { 332 if mock == nil { 333 panic("mock must not be nil. Use myMock := NewMockHelmer().") 334 } 335 params := []pegomock.Param{_param0} 336 pegomock.GetGenericMockFrom(mock).Invoke("SetCWD", params, []reflect.Type{}) 337 } 338 339 func (mock *MockHelmer) SetHelmBinary(_param0 string) { 340 if mock == nil { 341 panic("mock must not be nil. Use myMock := NewMockHelmer().") 342 } 343 params := []pegomock.Param{_param0} 344 pegomock.GetGenericMockFrom(mock).Invoke("SetHelmBinary", params, []reflect.Type{}) 345 } 346 347 func (mock *MockHelmer) SetHost(_param0 string) { 348 if mock == nil { 349 panic("mock must not be nil. Use myMock := NewMockHelmer().") 350 } 351 params := []pegomock.Param{_param0} 352 pegomock.GetGenericMockFrom(mock).Invoke("SetHost", params, []reflect.Type{}) 353 } 354 355 func (mock *MockHelmer) StatusRelease(_param0 string, _param1 string) error { 356 if mock == nil { 357 panic("mock must not be nil. Use myMock := NewMockHelmer().") 358 } 359 params := []pegomock.Param{_param0, _param1} 360 result := pegomock.GetGenericMockFrom(mock).Invoke("StatusRelease", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()}) 361 var ret0 error 362 if len(result) != 0 { 363 if result[0] != nil { 364 ret0 = result[0].(error) 365 } 366 } 367 return ret0 368 } 369 370 func (mock *MockHelmer) StatusReleaseWithOutput(_param0 string, _param1 string, _param2 string) (string, error) { 371 if mock == nil { 372 panic("mock must not be nil. Use myMock := NewMockHelmer().") 373 } 374 params := []pegomock.Param{_param0, _param1, _param2} 375 result := pegomock.GetGenericMockFrom(mock).Invoke("StatusReleaseWithOutput", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()}) 376 var ret0 string 377 var ret1 error 378 if len(result) != 0 { 379 if result[0] != nil { 380 ret0 = result[0].(string) 381 } 382 if result[1] != nil { 383 ret1 = result[1].(error) 384 } 385 } 386 return ret0, ret1 387 } 388 389 func (mock *MockHelmer) Template(_param0 string, _param1 string, _param2 string, _param3 string, _param4 bool, _param5 []string, _param6 []string, _param7 []string) error { 390 if mock == nil { 391 panic("mock must not be nil. Use myMock := NewMockHelmer().") 392 } 393 params := []pegomock.Param{_param0, _param1, _param2, _param3, _param4, _param5, _param6, _param7} 394 result := pegomock.GetGenericMockFrom(mock).Invoke("Template", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()}) 395 var ret0 error 396 if len(result) != 0 { 397 if result[0] != nil { 398 ret0 = result[0].(error) 399 } 400 } 401 return ret0 402 } 403 404 func (mock *MockHelmer) UpdateRepo() error { 405 if mock == nil { 406 panic("mock must not be nil. Use myMock := NewMockHelmer().") 407 } 408 params := []pegomock.Param{} 409 result := pegomock.GetGenericMockFrom(mock).Invoke("UpdateRepo", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()}) 410 var ret0 error 411 if len(result) != 0 { 412 if result[0] != nil { 413 ret0 = result[0].(error) 414 } 415 } 416 return ret0 417 } 418 419 func (mock *MockHelmer) UpgradeChart(_param0 string, _param1 string, _param2 string, _param3 string, _param4 bool, _param5 int, _param6 bool, _param7 bool, _param8 []string, _param9 []string, _param10 []string, _param11 string, _param12 string, _param13 string) error { 420 if mock == nil { 421 panic("mock must not be nil. Use myMock := NewMockHelmer().") 422 } 423 params := []pegomock.Param{_param0, _param1, _param2, _param3, _param4, _param5, _param6, _param7, _param8, _param9, _param10, _param11, _param12, _param13} 424 result := pegomock.GetGenericMockFrom(mock).Invoke("UpgradeChart", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()}) 425 var ret0 error 426 if len(result) != 0 { 427 if result[0] != nil { 428 ret0 = result[0].(error) 429 } 430 } 431 return ret0 432 } 433 434 func (mock *MockHelmer) Version(_param0 bool) (string, error) { 435 if mock == nil { 436 panic("mock must not be nil. Use myMock := NewMockHelmer().") 437 } 438 params := []pegomock.Param{_param0} 439 result := pegomock.GetGenericMockFrom(mock).Invoke("Version", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()}) 440 var ret0 string 441 var ret1 error 442 if len(result) != 0 { 443 if result[0] != nil { 444 ret0 = result[0].(string) 445 } 446 if result[1] != nil { 447 ret1 = result[1].(error) 448 } 449 } 450 return ret0, ret1 451 } 452 453 func (mock *MockHelmer) VerifyWasCalledOnce() *VerifierMockHelmer { 454 return &VerifierMockHelmer{ 455 mock: mock, 456 invocationCountMatcher: pegomock.Times(1), 457 } 458 } 459 460 func (mock *MockHelmer) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierMockHelmer { 461 return &VerifierMockHelmer{ 462 mock: mock, 463 invocationCountMatcher: invocationCountMatcher, 464 } 465 } 466 467 func (mock *MockHelmer) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, inOrderContext *pegomock.InOrderContext) *VerifierMockHelmer { 468 return &VerifierMockHelmer{ 469 mock: mock, 470 invocationCountMatcher: invocationCountMatcher, 471 inOrderContext: inOrderContext, 472 } 473 } 474 475 func (mock *MockHelmer) VerifyWasCalledEventually(invocationCountMatcher pegomock.Matcher, timeout time.Duration) *VerifierMockHelmer { 476 return &VerifierMockHelmer{ 477 mock: mock, 478 invocationCountMatcher: invocationCountMatcher, 479 timeout: timeout, 480 } 481 } 482 483 type VerifierMockHelmer struct { 484 mock *MockHelmer 485 invocationCountMatcher pegomock.Matcher 486 inOrderContext *pegomock.InOrderContext 487 timeout time.Duration 488 } 489 490 func (verifier *VerifierMockHelmer) AddRepo(_param0 string, _param1 string, _param2 string, _param3 string) *MockHelmer_AddRepo_OngoingVerification { 491 params := []pegomock.Param{_param0, _param1, _param2, _param3} 492 methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "AddRepo", params, verifier.timeout) 493 return &MockHelmer_AddRepo_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations} 494 } 495 496 type MockHelmer_AddRepo_OngoingVerification struct { 497 mock *MockHelmer 498 methodInvocations []pegomock.MethodInvocation 499 } 500 501 func (c *MockHelmer_AddRepo_OngoingVerification) GetCapturedArguments() (string, string, string, string) { 502 _param0, _param1, _param2, _param3 := c.GetAllCapturedArguments() 503 return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1], _param3[len(_param3)-1] 504 } 505 506 func (c *MockHelmer_AddRepo_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []string, _param3 []string) { 507 params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations) 508 if len(params) > 0 { 509 _param0 = make([]string, len(c.methodInvocations)) 510 for u, param := range params[0] { 511 _param0[u] = param.(string) 512 } 513 _param1 = make([]string, len(c.methodInvocations)) 514 for u, param := range params[1] { 515 _param1[u] = param.(string) 516 } 517 _param2 = make([]string, len(c.methodInvocations)) 518 for u, param := range params[2] { 519 _param2[u] = param.(string) 520 } 521 _param3 = make([]string, len(c.methodInvocations)) 522 for u, param := range params[3] { 523 _param3[u] = param.(string) 524 } 525 } 526 return 527 } 528 529 func (verifier *VerifierMockHelmer) BuildDependency() *MockHelmer_BuildDependency_OngoingVerification { 530 params := []pegomock.Param{} 531 methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "BuildDependency", params, verifier.timeout) 532 return &MockHelmer_BuildDependency_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations} 533 } 534 535 type MockHelmer_BuildDependency_OngoingVerification struct { 536 mock *MockHelmer 537 methodInvocations []pegomock.MethodInvocation 538 } 539 540 func (c *MockHelmer_BuildDependency_OngoingVerification) GetCapturedArguments() { 541 } 542 543 func (c *MockHelmer_BuildDependency_OngoingVerification) GetAllCapturedArguments() { 544 } 545 546 func (verifier *VerifierMockHelmer) DecryptSecrets(_param0 string) *MockHelmer_DecryptSecrets_OngoingVerification { 547 params := []pegomock.Param{_param0} 548 methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "DecryptSecrets", params, verifier.timeout) 549 return &MockHelmer_DecryptSecrets_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations} 550 } 551 552 type MockHelmer_DecryptSecrets_OngoingVerification struct { 553 mock *MockHelmer 554 methodInvocations []pegomock.MethodInvocation 555 } 556 557 func (c *MockHelmer_DecryptSecrets_OngoingVerification) GetCapturedArguments() string { 558 _param0 := c.GetAllCapturedArguments() 559 return _param0[len(_param0)-1] 560 } 561 562 func (c *MockHelmer_DecryptSecrets_OngoingVerification) GetAllCapturedArguments() (_param0 []string) { 563 params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations) 564 if len(params) > 0 { 565 _param0 = make([]string, len(c.methodInvocations)) 566 for u, param := range params[0] { 567 _param0[u] = param.(string) 568 } 569 } 570 return 571 } 572 573 func (verifier *VerifierMockHelmer) DeleteRelease(_param0 string, _param1 string, _param2 bool) *MockHelmer_DeleteRelease_OngoingVerification { 574 params := []pegomock.Param{_param0, _param1, _param2} 575 methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "DeleteRelease", params, verifier.timeout) 576 return &MockHelmer_DeleteRelease_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations} 577 } 578 579 type MockHelmer_DeleteRelease_OngoingVerification struct { 580 mock *MockHelmer 581 methodInvocations []pegomock.MethodInvocation 582 } 583 584 func (c *MockHelmer_DeleteRelease_OngoingVerification) GetCapturedArguments() (string, string, bool) { 585 _param0, _param1, _param2 := c.GetAllCapturedArguments() 586 return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1] 587 } 588 589 func (c *MockHelmer_DeleteRelease_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []bool) { 590 params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations) 591 if len(params) > 0 { 592 _param0 = make([]string, len(c.methodInvocations)) 593 for u, param := range params[0] { 594 _param0[u] = param.(string) 595 } 596 _param1 = make([]string, len(c.methodInvocations)) 597 for u, param := range params[1] { 598 _param1[u] = param.(string) 599 } 600 _param2 = make([]bool, len(c.methodInvocations)) 601 for u, param := range params[2] { 602 _param2[u] = param.(bool) 603 } 604 } 605 return 606 } 607 608 func (verifier *VerifierMockHelmer) Env() *MockHelmer_Env_OngoingVerification { 609 params := []pegomock.Param{} 610 methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Env", params, verifier.timeout) 611 return &MockHelmer_Env_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations} 612 } 613 614 type MockHelmer_Env_OngoingVerification struct { 615 mock *MockHelmer 616 methodInvocations []pegomock.MethodInvocation 617 } 618 619 func (c *MockHelmer_Env_OngoingVerification) GetCapturedArguments() { 620 } 621 622 func (c *MockHelmer_Env_OngoingVerification) GetAllCapturedArguments() { 623 } 624 625 func (verifier *VerifierMockHelmer) FetchChart(_param0 string, _param1 string, _param2 bool, _param3 string, _param4 string, _param5 string, _param6 string) *MockHelmer_FetchChart_OngoingVerification { 626 params := []pegomock.Param{_param0, _param1, _param2, _param3, _param4, _param5, _param6} 627 methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "FetchChart", params, verifier.timeout) 628 return &MockHelmer_FetchChart_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations} 629 } 630 631 type MockHelmer_FetchChart_OngoingVerification struct { 632 mock *MockHelmer 633 methodInvocations []pegomock.MethodInvocation 634 } 635 636 func (c *MockHelmer_FetchChart_OngoingVerification) GetCapturedArguments() (string, string, bool, string, string, string, string) { 637 _param0, _param1, _param2, _param3, _param4, _param5, _param6 := c.GetAllCapturedArguments() 638 return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1], _param3[len(_param3)-1], _param4[len(_param4)-1], _param5[len(_param5)-1], _param6[len(_param6)-1] 639 } 640 641 func (c *MockHelmer_FetchChart_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []bool, _param3 []string, _param4 []string, _param5 []string, _param6 []string) { 642 params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations) 643 if len(params) > 0 { 644 _param0 = make([]string, len(c.methodInvocations)) 645 for u, param := range params[0] { 646 _param0[u] = param.(string) 647 } 648 _param1 = make([]string, len(c.methodInvocations)) 649 for u, param := range params[1] { 650 _param1[u] = param.(string) 651 } 652 _param2 = make([]bool, len(c.methodInvocations)) 653 for u, param := range params[2] { 654 _param2[u] = param.(bool) 655 } 656 _param3 = make([]string, len(c.methodInvocations)) 657 for u, param := range params[3] { 658 _param3[u] = param.(string) 659 } 660 _param4 = make([]string, len(c.methodInvocations)) 661 for u, param := range params[4] { 662 _param4[u] = param.(string) 663 } 664 _param5 = make([]string, len(c.methodInvocations)) 665 for u, param := range params[5] { 666 _param5[u] = param.(string) 667 } 668 _param6 = make([]string, len(c.methodInvocations)) 669 for u, param := range params[6] { 670 _param6[u] = param.(string) 671 } 672 } 673 return 674 } 675 676 func (verifier *VerifierMockHelmer) FindChart() *MockHelmer_FindChart_OngoingVerification { 677 params := []pegomock.Param{} 678 methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "FindChart", params, verifier.timeout) 679 return &MockHelmer_FindChart_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations} 680 } 681 682 type MockHelmer_FindChart_OngoingVerification struct { 683 mock *MockHelmer 684 methodInvocations []pegomock.MethodInvocation 685 } 686 687 func (c *MockHelmer_FindChart_OngoingVerification) GetCapturedArguments() { 688 } 689 690 func (c *MockHelmer_FindChart_OngoingVerification) GetAllCapturedArguments() { 691 } 692 693 func (verifier *VerifierMockHelmer) HelmBinary() *MockHelmer_HelmBinary_OngoingVerification { 694 params := []pegomock.Param{} 695 methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "HelmBinary", params, verifier.timeout) 696 return &MockHelmer_HelmBinary_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations} 697 } 698 699 type MockHelmer_HelmBinary_OngoingVerification struct { 700 mock *MockHelmer 701 methodInvocations []pegomock.MethodInvocation 702 } 703 704 func (c *MockHelmer_HelmBinary_OngoingVerification) GetCapturedArguments() { 705 } 706 707 func (c *MockHelmer_HelmBinary_OngoingVerification) GetAllCapturedArguments() { 708 } 709 710 func (verifier *VerifierMockHelmer) Init(_param0 bool, _param1 string, _param2 string, _param3 bool) *MockHelmer_Init_OngoingVerification { 711 params := []pegomock.Param{_param0, _param1, _param2, _param3} 712 methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Init", params, verifier.timeout) 713 return &MockHelmer_Init_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations} 714 } 715 716 type MockHelmer_Init_OngoingVerification struct { 717 mock *MockHelmer 718 methodInvocations []pegomock.MethodInvocation 719 } 720 721 func (c *MockHelmer_Init_OngoingVerification) GetCapturedArguments() (bool, string, string, bool) { 722 _param0, _param1, _param2, _param3 := c.GetAllCapturedArguments() 723 return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1], _param3[len(_param3)-1] 724 } 725 726 func (c *MockHelmer_Init_OngoingVerification) GetAllCapturedArguments() (_param0 []bool, _param1 []string, _param2 []string, _param3 []bool) { 727 params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations) 728 if len(params) > 0 { 729 _param0 = make([]bool, len(c.methodInvocations)) 730 for u, param := range params[0] { 731 _param0[u] = param.(bool) 732 } 733 _param1 = make([]string, len(c.methodInvocations)) 734 for u, param := range params[1] { 735 _param1[u] = param.(string) 736 } 737 _param2 = make([]string, len(c.methodInvocations)) 738 for u, param := range params[2] { 739 _param2[u] = param.(string) 740 } 741 _param3 = make([]bool, len(c.methodInvocations)) 742 for u, param := range params[3] { 743 _param3[u] = param.(bool) 744 } 745 } 746 return 747 } 748 749 func (verifier *VerifierMockHelmer) InstallChart(_param0 string, _param1 string, _param2 string, _param3 string, _param4 int, _param5 []string, _param6 []string, _param7 []string, _param8 string, _param9 string, _param10 string) *MockHelmer_InstallChart_OngoingVerification { 750 params := []pegomock.Param{_param0, _param1, _param2, _param3, _param4, _param5, _param6, _param7, _param8, _param9, _param10} 751 methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "InstallChart", params, verifier.timeout) 752 return &MockHelmer_InstallChart_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations} 753 } 754 755 type MockHelmer_InstallChart_OngoingVerification struct { 756 mock *MockHelmer 757 methodInvocations []pegomock.MethodInvocation 758 } 759 760 func (c *MockHelmer_InstallChart_OngoingVerification) GetCapturedArguments() (string, string, string, string, int, []string, []string, []string, string, string, string) { 761 _param0, _param1, _param2, _param3, _param4, _param5, _param6, _param7, _param8, _param9, _param10 := c.GetAllCapturedArguments() 762 return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1], _param3[len(_param3)-1], _param4[len(_param4)-1], _param5[len(_param5)-1], _param6[len(_param6)-1], _param7[len(_param7)-1], _param8[len(_param8)-1], _param9[len(_param9)-1], _param10[len(_param10)-1] 763 } 764 765 func (c *MockHelmer_InstallChart_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []string, _param3 []string, _param4 []int, _param5 [][]string, _param6 [][]string, _param7 [][]string, _param8 []string, _param9 []string, _param10 []string) { 766 params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations) 767 if len(params) > 0 { 768 _param0 = make([]string, len(c.methodInvocations)) 769 for u, param := range params[0] { 770 _param0[u] = param.(string) 771 } 772 _param1 = make([]string, len(c.methodInvocations)) 773 for u, param := range params[1] { 774 _param1[u] = param.(string) 775 } 776 _param2 = make([]string, len(c.methodInvocations)) 777 for u, param := range params[2] { 778 _param2[u] = param.(string) 779 } 780 _param3 = make([]string, len(c.methodInvocations)) 781 for u, param := range params[3] { 782 _param3[u] = param.(string) 783 } 784 _param4 = make([]int, len(c.methodInvocations)) 785 for u, param := range params[4] { 786 _param4[u] = param.(int) 787 } 788 _param5 = make([][]string, len(c.methodInvocations)) 789 for u, param := range params[5] { 790 _param5[u] = param.([]string) 791 } 792 _param6 = make([][]string, len(c.methodInvocations)) 793 for u, param := range params[6] { 794 _param6[u] = param.([]string) 795 } 796 _param7 = make([][]string, len(c.methodInvocations)) 797 for u, param := range params[7] { 798 _param7[u] = param.([]string) 799 } 800 _param8 = make([]string, len(c.methodInvocations)) 801 for u, param := range params[8] { 802 _param8[u] = param.(string) 803 } 804 _param9 = make([]string, len(c.methodInvocations)) 805 for u, param := range params[9] { 806 _param9[u] = param.(string) 807 } 808 _param10 = make([]string, len(c.methodInvocations)) 809 for u, param := range params[10] { 810 _param10[u] = param.(string) 811 } 812 } 813 return 814 } 815 816 func (verifier *VerifierMockHelmer) IsRepoMissing(_param0 string) *MockHelmer_IsRepoMissing_OngoingVerification { 817 params := []pegomock.Param{_param0} 818 methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "IsRepoMissing", params, verifier.timeout) 819 return &MockHelmer_IsRepoMissing_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations} 820 } 821 822 type MockHelmer_IsRepoMissing_OngoingVerification struct { 823 mock *MockHelmer 824 methodInvocations []pegomock.MethodInvocation 825 } 826 827 func (c *MockHelmer_IsRepoMissing_OngoingVerification) GetCapturedArguments() string { 828 _param0 := c.GetAllCapturedArguments() 829 return _param0[len(_param0)-1] 830 } 831 832 func (c *MockHelmer_IsRepoMissing_OngoingVerification) GetAllCapturedArguments() (_param0 []string) { 833 params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations) 834 if len(params) > 0 { 835 _param0 = make([]string, len(c.methodInvocations)) 836 for u, param := range params[0] { 837 _param0[u] = param.(string) 838 } 839 } 840 return 841 } 842 843 func (verifier *VerifierMockHelmer) Lint(_param0 []string) *MockHelmer_Lint_OngoingVerification { 844 params := []pegomock.Param{_param0} 845 methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Lint", params, verifier.timeout) 846 return &MockHelmer_Lint_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations} 847 } 848 849 type MockHelmer_Lint_OngoingVerification struct { 850 mock *MockHelmer 851 methodInvocations []pegomock.MethodInvocation 852 } 853 854 func (c *MockHelmer_Lint_OngoingVerification) GetCapturedArguments() []string { 855 _param0 := c.GetAllCapturedArguments() 856 return _param0[len(_param0)-1] 857 } 858 859 func (c *MockHelmer_Lint_OngoingVerification) GetAllCapturedArguments() (_param0 [][]string) { 860 params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations) 861 if len(params) > 0 { 862 _param0 = make([][]string, len(c.methodInvocations)) 863 for u, param := range params[0] { 864 _param0[u] = param.([]string) 865 } 866 } 867 return 868 } 869 870 func (verifier *VerifierMockHelmer) ListReleases(_param0 string) *MockHelmer_ListReleases_OngoingVerification { 871 params := []pegomock.Param{_param0} 872 methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ListReleases", params, verifier.timeout) 873 return &MockHelmer_ListReleases_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations} 874 } 875 876 type MockHelmer_ListReleases_OngoingVerification struct { 877 mock *MockHelmer 878 methodInvocations []pegomock.MethodInvocation 879 } 880 881 func (c *MockHelmer_ListReleases_OngoingVerification) GetCapturedArguments() string { 882 _param0 := c.GetAllCapturedArguments() 883 return _param0[len(_param0)-1] 884 } 885 886 func (c *MockHelmer_ListReleases_OngoingVerification) GetAllCapturedArguments() (_param0 []string) { 887 params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations) 888 if len(params) > 0 { 889 _param0 = make([]string, len(c.methodInvocations)) 890 for u, param := range params[0] { 891 _param0[u] = param.(string) 892 } 893 } 894 return 895 } 896 897 func (verifier *VerifierMockHelmer) ListRepos() *MockHelmer_ListRepos_OngoingVerification { 898 params := []pegomock.Param{} 899 methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ListRepos", params, verifier.timeout) 900 return &MockHelmer_ListRepos_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations} 901 } 902 903 type MockHelmer_ListRepos_OngoingVerification struct { 904 mock *MockHelmer 905 methodInvocations []pegomock.MethodInvocation 906 } 907 908 func (c *MockHelmer_ListRepos_OngoingVerification) GetCapturedArguments() { 909 } 910 911 func (c *MockHelmer_ListRepos_OngoingVerification) GetAllCapturedArguments() { 912 } 913 914 func (verifier *VerifierMockHelmer) PackageChart() *MockHelmer_PackageChart_OngoingVerification { 915 params := []pegomock.Param{} 916 methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "PackageChart", params, verifier.timeout) 917 return &MockHelmer_PackageChart_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations} 918 } 919 920 type MockHelmer_PackageChart_OngoingVerification struct { 921 mock *MockHelmer 922 methodInvocations []pegomock.MethodInvocation 923 } 924 925 func (c *MockHelmer_PackageChart_OngoingVerification) GetCapturedArguments() { 926 } 927 928 func (c *MockHelmer_PackageChart_OngoingVerification) GetAllCapturedArguments() { 929 } 930 931 func (verifier *VerifierMockHelmer) RemoveRepo(_param0 string) *MockHelmer_RemoveRepo_OngoingVerification { 932 params := []pegomock.Param{_param0} 933 methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "RemoveRepo", params, verifier.timeout) 934 return &MockHelmer_RemoveRepo_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations} 935 } 936 937 type MockHelmer_RemoveRepo_OngoingVerification struct { 938 mock *MockHelmer 939 methodInvocations []pegomock.MethodInvocation 940 } 941 942 func (c *MockHelmer_RemoveRepo_OngoingVerification) GetCapturedArguments() string { 943 _param0 := c.GetAllCapturedArguments() 944 return _param0[len(_param0)-1] 945 } 946 947 func (c *MockHelmer_RemoveRepo_OngoingVerification) GetAllCapturedArguments() (_param0 []string) { 948 params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations) 949 if len(params) > 0 { 950 _param0 = make([]string, len(c.methodInvocations)) 951 for u, param := range params[0] { 952 _param0[u] = param.(string) 953 } 954 } 955 return 956 } 957 958 func (verifier *VerifierMockHelmer) RemoveRequirementsLock() *MockHelmer_RemoveRequirementsLock_OngoingVerification { 959 params := []pegomock.Param{} 960 methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "RemoveRequirementsLock", params, verifier.timeout) 961 return &MockHelmer_RemoveRequirementsLock_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations} 962 } 963 964 type MockHelmer_RemoveRequirementsLock_OngoingVerification struct { 965 mock *MockHelmer 966 methodInvocations []pegomock.MethodInvocation 967 } 968 969 func (c *MockHelmer_RemoveRequirementsLock_OngoingVerification) GetCapturedArguments() { 970 } 971 972 func (c *MockHelmer_RemoveRequirementsLock_OngoingVerification) GetAllCapturedArguments() { 973 } 974 975 func (verifier *VerifierMockHelmer) SearchCharts(_param0 string, _param1 bool) *MockHelmer_SearchCharts_OngoingVerification { 976 params := []pegomock.Param{_param0, _param1} 977 methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "SearchCharts", params, verifier.timeout) 978 return &MockHelmer_SearchCharts_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations} 979 } 980 981 type MockHelmer_SearchCharts_OngoingVerification struct { 982 mock *MockHelmer 983 methodInvocations []pegomock.MethodInvocation 984 } 985 986 func (c *MockHelmer_SearchCharts_OngoingVerification) GetCapturedArguments() (string, bool) { 987 _param0, _param1 := c.GetAllCapturedArguments() 988 return _param0[len(_param0)-1], _param1[len(_param1)-1] 989 } 990 991 func (c *MockHelmer_SearchCharts_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []bool) { 992 params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations) 993 if len(params) > 0 { 994 _param0 = make([]string, len(c.methodInvocations)) 995 for u, param := range params[0] { 996 _param0[u] = param.(string) 997 } 998 _param1 = make([]bool, len(c.methodInvocations)) 999 for u, param := range params[1] { 1000 _param1[u] = param.(bool) 1001 } 1002 } 1003 return 1004 } 1005 1006 func (verifier *VerifierMockHelmer) SetCWD(_param0 string) *MockHelmer_SetCWD_OngoingVerification { 1007 params := []pegomock.Param{_param0} 1008 methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "SetCWD", params, verifier.timeout) 1009 return &MockHelmer_SetCWD_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations} 1010 } 1011 1012 type MockHelmer_SetCWD_OngoingVerification struct { 1013 mock *MockHelmer 1014 methodInvocations []pegomock.MethodInvocation 1015 } 1016 1017 func (c *MockHelmer_SetCWD_OngoingVerification) GetCapturedArguments() string { 1018 _param0 := c.GetAllCapturedArguments() 1019 return _param0[len(_param0)-1] 1020 } 1021 1022 func (c *MockHelmer_SetCWD_OngoingVerification) GetAllCapturedArguments() (_param0 []string) { 1023 params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations) 1024 if len(params) > 0 { 1025 _param0 = make([]string, len(c.methodInvocations)) 1026 for u, param := range params[0] { 1027 _param0[u] = param.(string) 1028 } 1029 } 1030 return 1031 } 1032 1033 func (verifier *VerifierMockHelmer) SetHelmBinary(_param0 string) *MockHelmer_SetHelmBinary_OngoingVerification { 1034 params := []pegomock.Param{_param0} 1035 methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "SetHelmBinary", params, verifier.timeout) 1036 return &MockHelmer_SetHelmBinary_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations} 1037 } 1038 1039 type MockHelmer_SetHelmBinary_OngoingVerification struct { 1040 mock *MockHelmer 1041 methodInvocations []pegomock.MethodInvocation 1042 } 1043 1044 func (c *MockHelmer_SetHelmBinary_OngoingVerification) GetCapturedArguments() string { 1045 _param0 := c.GetAllCapturedArguments() 1046 return _param0[len(_param0)-1] 1047 } 1048 1049 func (c *MockHelmer_SetHelmBinary_OngoingVerification) GetAllCapturedArguments() (_param0 []string) { 1050 params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations) 1051 if len(params) > 0 { 1052 _param0 = make([]string, len(c.methodInvocations)) 1053 for u, param := range params[0] { 1054 _param0[u] = param.(string) 1055 } 1056 } 1057 return 1058 } 1059 1060 func (verifier *VerifierMockHelmer) SetHost(_param0 string) *MockHelmer_SetHost_OngoingVerification { 1061 params := []pegomock.Param{_param0} 1062 methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "SetHost", params, verifier.timeout) 1063 return &MockHelmer_SetHost_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations} 1064 } 1065 1066 type MockHelmer_SetHost_OngoingVerification struct { 1067 mock *MockHelmer 1068 methodInvocations []pegomock.MethodInvocation 1069 } 1070 1071 func (c *MockHelmer_SetHost_OngoingVerification) GetCapturedArguments() string { 1072 _param0 := c.GetAllCapturedArguments() 1073 return _param0[len(_param0)-1] 1074 } 1075 1076 func (c *MockHelmer_SetHost_OngoingVerification) GetAllCapturedArguments() (_param0 []string) { 1077 params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations) 1078 if len(params) > 0 { 1079 _param0 = make([]string, len(c.methodInvocations)) 1080 for u, param := range params[0] { 1081 _param0[u] = param.(string) 1082 } 1083 } 1084 return 1085 } 1086 1087 func (verifier *VerifierMockHelmer) StatusRelease(_param0 string, _param1 string) *MockHelmer_StatusRelease_OngoingVerification { 1088 params := []pegomock.Param{_param0, _param1} 1089 methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "StatusRelease", params, verifier.timeout) 1090 return &MockHelmer_StatusRelease_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations} 1091 } 1092 1093 type MockHelmer_StatusRelease_OngoingVerification struct { 1094 mock *MockHelmer 1095 methodInvocations []pegomock.MethodInvocation 1096 } 1097 1098 func (c *MockHelmer_StatusRelease_OngoingVerification) GetCapturedArguments() (string, string) { 1099 _param0, _param1 := c.GetAllCapturedArguments() 1100 return _param0[len(_param0)-1], _param1[len(_param1)-1] 1101 } 1102 1103 func (c *MockHelmer_StatusRelease_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) { 1104 params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations) 1105 if len(params) > 0 { 1106 _param0 = make([]string, len(c.methodInvocations)) 1107 for u, param := range params[0] { 1108 _param0[u] = param.(string) 1109 } 1110 _param1 = make([]string, len(c.methodInvocations)) 1111 for u, param := range params[1] { 1112 _param1[u] = param.(string) 1113 } 1114 } 1115 return 1116 } 1117 1118 func (verifier *VerifierMockHelmer) StatusReleaseWithOutput(_param0 string, _param1 string, _param2 string) *MockHelmer_StatusReleaseWithOutput_OngoingVerification { 1119 params := []pegomock.Param{_param0, _param1, _param2} 1120 methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "StatusReleaseWithOutput", params, verifier.timeout) 1121 return &MockHelmer_StatusReleaseWithOutput_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations} 1122 } 1123 1124 type MockHelmer_StatusReleaseWithOutput_OngoingVerification struct { 1125 mock *MockHelmer 1126 methodInvocations []pegomock.MethodInvocation 1127 } 1128 1129 func (c *MockHelmer_StatusReleaseWithOutput_OngoingVerification) GetCapturedArguments() (string, string, string) { 1130 _param0, _param1, _param2 := c.GetAllCapturedArguments() 1131 return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1] 1132 } 1133 1134 func (c *MockHelmer_StatusReleaseWithOutput_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []string) { 1135 params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations) 1136 if len(params) > 0 { 1137 _param0 = make([]string, len(c.methodInvocations)) 1138 for u, param := range params[0] { 1139 _param0[u] = param.(string) 1140 } 1141 _param1 = make([]string, len(c.methodInvocations)) 1142 for u, param := range params[1] { 1143 _param1[u] = param.(string) 1144 } 1145 _param2 = make([]string, len(c.methodInvocations)) 1146 for u, param := range params[2] { 1147 _param2[u] = param.(string) 1148 } 1149 } 1150 return 1151 } 1152 1153 func (verifier *VerifierMockHelmer) Template(_param0 string, _param1 string, _param2 string, _param3 string, _param4 bool, _param5 []string, _param6 []string, _param7 []string) *MockHelmer_Template_OngoingVerification { 1154 params := []pegomock.Param{_param0, _param1, _param2, _param3, _param4, _param5, _param6, _param7} 1155 methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Template", params, verifier.timeout) 1156 return &MockHelmer_Template_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations} 1157 } 1158 1159 type MockHelmer_Template_OngoingVerification struct { 1160 mock *MockHelmer 1161 methodInvocations []pegomock.MethodInvocation 1162 } 1163 1164 func (c *MockHelmer_Template_OngoingVerification) GetCapturedArguments() (string, string, string, string, bool, []string, []string, []string) { 1165 _param0, _param1, _param2, _param3, _param4, _param5, _param6, _param7 := c.GetAllCapturedArguments() 1166 return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1], _param3[len(_param3)-1], _param4[len(_param4)-1], _param5[len(_param5)-1], _param6[len(_param6)-1], _param7[len(_param7)-1] 1167 } 1168 1169 func (c *MockHelmer_Template_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []string, _param3 []string, _param4 []bool, _param5 [][]string, _param6 [][]string, _param7 [][]string) { 1170 params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations) 1171 if len(params) > 0 { 1172 _param0 = make([]string, len(c.methodInvocations)) 1173 for u, param := range params[0] { 1174 _param0[u] = param.(string) 1175 } 1176 _param1 = make([]string, len(c.methodInvocations)) 1177 for u, param := range params[1] { 1178 _param1[u] = param.(string) 1179 } 1180 _param2 = make([]string, len(c.methodInvocations)) 1181 for u, param := range params[2] { 1182 _param2[u] = param.(string) 1183 } 1184 _param3 = make([]string, len(c.methodInvocations)) 1185 for u, param := range params[3] { 1186 _param3[u] = param.(string) 1187 } 1188 _param4 = make([]bool, len(c.methodInvocations)) 1189 for u, param := range params[4] { 1190 _param4[u] = param.(bool) 1191 } 1192 _param5 = make([][]string, len(c.methodInvocations)) 1193 for u, param := range params[5] { 1194 _param5[u] = param.([]string) 1195 } 1196 _param6 = make([][]string, len(c.methodInvocations)) 1197 for u, param := range params[6] { 1198 _param6[u] = param.([]string) 1199 } 1200 _param7 = make([][]string, len(c.methodInvocations)) 1201 for u, param := range params[7] { 1202 _param7[u] = param.([]string) 1203 } 1204 } 1205 return 1206 } 1207 1208 func (verifier *VerifierMockHelmer) UpdateRepo() *MockHelmer_UpdateRepo_OngoingVerification { 1209 params := []pegomock.Param{} 1210 methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "UpdateRepo", params, verifier.timeout) 1211 return &MockHelmer_UpdateRepo_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations} 1212 } 1213 1214 type MockHelmer_UpdateRepo_OngoingVerification struct { 1215 mock *MockHelmer 1216 methodInvocations []pegomock.MethodInvocation 1217 } 1218 1219 func (c *MockHelmer_UpdateRepo_OngoingVerification) GetCapturedArguments() { 1220 } 1221 1222 func (c *MockHelmer_UpdateRepo_OngoingVerification) GetAllCapturedArguments() { 1223 } 1224 1225 func (verifier *VerifierMockHelmer) UpgradeChart(_param0 string, _param1 string, _param2 string, _param3 string, _param4 bool, _param5 int, _param6 bool, _param7 bool, _param8 []string, _param9 []string, _param10 []string, _param11 string, _param12 string, _param13 string) *MockHelmer_UpgradeChart_OngoingVerification { 1226 params := []pegomock.Param{_param0, _param1, _param2, _param3, _param4, _param5, _param6, _param7, _param8, _param9, _param10, _param11, _param12, _param13} 1227 methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "UpgradeChart", params, verifier.timeout) 1228 return &MockHelmer_UpgradeChart_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations} 1229 } 1230 1231 type MockHelmer_UpgradeChart_OngoingVerification struct { 1232 mock *MockHelmer 1233 methodInvocations []pegomock.MethodInvocation 1234 } 1235 1236 func (c *MockHelmer_UpgradeChart_OngoingVerification) GetCapturedArguments() (string, string, string, string, bool, int, bool, bool, []string, []string, []string, string, string, string) { 1237 _param0, _param1, _param2, _param3, _param4, _param5, _param6, _param7, _param8, _param9, _param10, _param11, _param12, _param13 := c.GetAllCapturedArguments() 1238 return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1], _param3[len(_param3)-1], _param4[len(_param4)-1], _param5[len(_param5)-1], _param6[len(_param6)-1], _param7[len(_param7)-1], _param8[len(_param8)-1], _param9[len(_param9)-1], _param10[len(_param10)-1], _param11[len(_param11)-1], _param12[len(_param12)-1], _param13[len(_param13)-1] 1239 } 1240 1241 func (c *MockHelmer_UpgradeChart_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []string, _param3 []string, _param4 []bool, _param5 []int, _param6 []bool, _param7 []bool, _param8 [][]string, _param9 [][]string, _param10 [][]string, _param11 []string, _param12 []string, _param13 []string) { 1242 params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations) 1243 if len(params) > 0 { 1244 _param0 = make([]string, len(c.methodInvocations)) 1245 for u, param := range params[0] { 1246 _param0[u] = param.(string) 1247 } 1248 _param1 = make([]string, len(c.methodInvocations)) 1249 for u, param := range params[1] { 1250 _param1[u] = param.(string) 1251 } 1252 _param2 = make([]string, len(c.methodInvocations)) 1253 for u, param := range params[2] { 1254 _param2[u] = param.(string) 1255 } 1256 _param3 = make([]string, len(c.methodInvocations)) 1257 for u, param := range params[3] { 1258 _param3[u] = param.(string) 1259 } 1260 _param4 = make([]bool, len(c.methodInvocations)) 1261 for u, param := range params[4] { 1262 _param4[u] = param.(bool) 1263 } 1264 _param5 = make([]int, len(c.methodInvocations)) 1265 for u, param := range params[5] { 1266 _param5[u] = param.(int) 1267 } 1268 _param6 = make([]bool, len(c.methodInvocations)) 1269 for u, param := range params[6] { 1270 _param6[u] = param.(bool) 1271 } 1272 _param7 = make([]bool, len(c.methodInvocations)) 1273 for u, param := range params[7] { 1274 _param7[u] = param.(bool) 1275 } 1276 _param8 = make([][]string, len(c.methodInvocations)) 1277 for u, param := range params[8] { 1278 _param8[u] = param.([]string) 1279 } 1280 _param9 = make([][]string, len(c.methodInvocations)) 1281 for u, param := range params[9] { 1282 _param9[u] = param.([]string) 1283 } 1284 _param10 = make([][]string, len(c.methodInvocations)) 1285 for u, param := range params[10] { 1286 _param10[u] = param.([]string) 1287 } 1288 _param11 = make([]string, len(c.methodInvocations)) 1289 for u, param := range params[11] { 1290 _param11[u] = param.(string) 1291 } 1292 _param12 = make([]string, len(c.methodInvocations)) 1293 for u, param := range params[12] { 1294 _param12[u] = param.(string) 1295 } 1296 _param13 = make([]string, len(c.methodInvocations)) 1297 for u, param := range params[13] { 1298 _param13[u] = param.(string) 1299 } 1300 } 1301 return 1302 } 1303 1304 func (verifier *VerifierMockHelmer) Version(_param0 bool) *MockHelmer_Version_OngoingVerification { 1305 params := []pegomock.Param{_param0} 1306 methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Version", params, verifier.timeout) 1307 return &MockHelmer_Version_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations} 1308 } 1309 1310 type MockHelmer_Version_OngoingVerification struct { 1311 mock *MockHelmer 1312 methodInvocations []pegomock.MethodInvocation 1313 } 1314 1315 func (c *MockHelmer_Version_OngoingVerification) GetCapturedArguments() bool { 1316 _param0 := c.GetAllCapturedArguments() 1317 return _param0[len(_param0)-1] 1318 } 1319 1320 func (c *MockHelmer_Version_OngoingVerification) GetAllCapturedArguments() (_param0 []bool) { 1321 params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations) 1322 if len(params) > 0 { 1323 _param0 = make([]bool, len(c.methodInvocations)) 1324 for u, param := range params[0] { 1325 _param0[u] = param.(bool) 1326 } 1327 } 1328 return 1329 }