Skip to content
Permalink
Branch: master
Find file Copy path
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
1317 lines (1171 sloc) 49.6 KB
// Code generated by pegomock. DO NOT EDIT.
// Source: github.com/jenkins-x/jx/pkg/helm (interfaces: Helmer)
package helm_test
import (
"reflect"
"time"
helm "github.com/jenkins-x/jx/pkg/helm"
pegomock "github.com/petergtz/pegomock"
)
type MockHelmer struct {
fail func(message string, callerSkip ...int)
}
func NewMockHelmer(options ...pegomock.Option) *MockHelmer {
mock := &MockHelmer{}
for _, option := range options {
option.Apply(mock)
}
return mock
}
func (mock *MockHelmer) SetFailHandler(fh pegomock.FailHandler) { mock.fail = fh }
func (mock *MockHelmer) FailHandler() pegomock.FailHandler { return mock.fail }
func (mock *MockHelmer) AddRepo(_param0 string, _param1 string, _param2 string, _param3 string) error {
if mock == nil {
panic("mock must not be nil. Use myMock := NewMockHelmer().")
}
params := []pegomock.Param{_param0, _param1, _param2, _param3}
result := pegomock.GetGenericMockFrom(mock).Invoke("AddRepo", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
var ret0 error
if len(result) != 0 {
if result[0] != nil {
ret0 = result[0].(error)
}
}
return ret0
}
func (mock *MockHelmer) BuildDependency() error {
if mock == nil {
panic("mock must not be nil. Use myMock := NewMockHelmer().")
}
params := []pegomock.Param{}
result := pegomock.GetGenericMockFrom(mock).Invoke("BuildDependency", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
var ret0 error
if len(result) != 0 {
if result[0] != nil {
ret0 = result[0].(error)
}
}
return ret0
}
func (mock *MockHelmer) DecryptSecrets(_param0 string) error {
if mock == nil {
panic("mock must not be nil. Use myMock := NewMockHelmer().")
}
params := []pegomock.Param{_param0}
result := pegomock.GetGenericMockFrom(mock).Invoke("DecryptSecrets", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
var ret0 error
if len(result) != 0 {
if result[0] != nil {
ret0 = result[0].(error)
}
}
return ret0
}
func (mock *MockHelmer) DeleteRelease(_param0 string, _param1 string, _param2 bool) error {
if mock == nil {
panic("mock must not be nil. Use myMock := NewMockHelmer().")
}
params := []pegomock.Param{_param0, _param1, _param2}
result := pegomock.GetGenericMockFrom(mock).Invoke("DeleteRelease", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
var ret0 error
if len(result) != 0 {
if result[0] != nil {
ret0 = result[0].(error)
}
}
return ret0
}
func (mock *MockHelmer) Env() map[string]string {
if mock == nil {
panic("mock must not be nil. Use myMock := NewMockHelmer().")
}
params := []pegomock.Param{}
result := pegomock.GetGenericMockFrom(mock).Invoke("Env", params, []reflect.Type{reflect.TypeOf((*map[string]string)(nil)).Elem()})
var ret0 map[string]string
if len(result) != 0 {
if result[0] != nil {
ret0 = result[0].(map[string]string)
}
}
return ret0
}
func (mock *MockHelmer) FetchChart(_param0 string, _param1 string, _param2 bool, _param3 string, _param4 string, _param5 string, _param6 string) error {
if mock == nil {
panic("mock must not be nil. Use myMock := NewMockHelmer().")
}
params := []pegomock.Param{_param0, _param1, _param2, _param3, _param4, _param5, _param6}
result := pegomock.GetGenericMockFrom(mock).Invoke("FetchChart", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
var ret0 error
if len(result) != 0 {
if result[0] != nil {
ret0 = result[0].(error)
}
}
return ret0
}
func (mock *MockHelmer) FindChart() (string, error) {
if mock == nil {
panic("mock must not be nil. Use myMock := NewMockHelmer().")
}
params := []pegomock.Param{}
result := pegomock.GetGenericMockFrom(mock).Invoke("FindChart", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
var ret0 string
var ret1 error
if len(result) != 0 {
if result[0] != nil {
ret0 = result[0].(string)
}
if result[1] != nil {
ret1 = result[1].(error)
}
}
return ret0, ret1
}
func (mock *MockHelmer) HelmBinary() string {
if mock == nil {
panic("mock must not be nil. Use myMock := NewMockHelmer().")
}
params := []pegomock.Param{}
result := pegomock.GetGenericMockFrom(mock).Invoke("HelmBinary", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem()})
var ret0 string
if len(result) != 0 {
if result[0] != nil {
ret0 = result[0].(string)
}
}
return ret0
}
func (mock *MockHelmer) Init(_param0 bool, _param1 string, _param2 string, _param3 bool) error {
if mock == nil {
panic("mock must not be nil. Use myMock := NewMockHelmer().")
}
params := []pegomock.Param{_param0, _param1, _param2, _param3}
result := pegomock.GetGenericMockFrom(mock).Invoke("Init", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
var ret0 error
if len(result) != 0 {
if result[0] != nil {
ret0 = result[0].(error)
}
}
return ret0
}
func (mock *MockHelmer) InstallChart(_param0 string, _param1 string, _param2 string, _param3 string, _param4 int, _param5 []string, _param6 []string, _param7 string, _param8 string, _param9 string) error {
if mock == nil {
panic("mock must not be nil. Use myMock := NewMockHelmer().")
}
params := []pegomock.Param{_param0, _param1, _param2, _param3, _param4, _param5, _param6, _param7, _param8, _param9}
result := pegomock.GetGenericMockFrom(mock).Invoke("InstallChart", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
var ret0 error
if len(result) != 0 {
if result[0] != nil {
ret0 = result[0].(error)
}
}
return ret0
}
func (mock *MockHelmer) IsRepoMissing(_param0 string) (bool, string, error) {
if mock == nil {
panic("mock must not be nil. Use myMock := NewMockHelmer().")
}
params := []pegomock.Param{_param0}
result := pegomock.GetGenericMockFrom(mock).Invoke("IsRepoMissing", params, []reflect.Type{reflect.TypeOf((*bool)(nil)).Elem(), reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
var ret0 bool
var ret1 string
var ret2 error
if len(result) != 0 {
if result[0] != nil {
ret0 = result[0].(bool)
}
if result[1] != nil {
ret1 = result[1].(string)
}
if result[2] != nil {
ret2 = result[2].(error)
}
}
return ret0, ret1, ret2
}
func (mock *MockHelmer) Lint(_param0 []string) (string, error) {
if mock == nil {
panic("mock must not be nil. Use myMock := NewMockHelmer().")
}
params := []pegomock.Param{_param0}
result := pegomock.GetGenericMockFrom(mock).Invoke("Lint", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
var ret0 string
var ret1 error
if len(result) != 0 {
if result[0] != nil {
ret0 = result[0].(string)
}
if result[1] != nil {
ret1 = result[1].(error)
}
}
return ret0, ret1
}
func (mock *MockHelmer) ListReleases(_param0 string) (map[string]helm.ReleaseSummary, []string, error) {
if mock == nil {
panic("mock must not be nil. Use myMock := NewMockHelmer().")
}
params := []pegomock.Param{_param0}
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()})
var ret0 map[string]helm.ReleaseSummary
var ret1 []string
var ret2 error
if len(result) != 0 {
if result[0] != nil {
ret0 = result[0].(map[string]helm.ReleaseSummary)
}
if result[1] != nil {
ret1 = result[1].([]string)
}
if result[2] != nil {
ret2 = result[2].(error)
}
}
return ret0, ret1, ret2
}
func (mock *MockHelmer) ListRepos() (map[string]string, error) {
if mock == nil {
panic("mock must not be nil. Use myMock := NewMockHelmer().")
}
params := []pegomock.Param{}
result := pegomock.GetGenericMockFrom(mock).Invoke("ListRepos", params, []reflect.Type{reflect.TypeOf((*map[string]string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
var ret0 map[string]string
var ret1 error
if len(result) != 0 {
if result[0] != nil {
ret0 = result[0].(map[string]string)
}
if result[1] != nil {
ret1 = result[1].(error)
}
}
return ret0, ret1
}
func (mock *MockHelmer) PackageChart() error {
if mock == nil {
panic("mock must not be nil. Use myMock := NewMockHelmer().")
}
params := []pegomock.Param{}
result := pegomock.GetGenericMockFrom(mock).Invoke("PackageChart", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
var ret0 error
if len(result) != 0 {
if result[0] != nil {
ret0 = result[0].(error)
}
}
return ret0
}
func (mock *MockHelmer) RemoveRepo(_param0 string) error {
if mock == nil {
panic("mock must not be nil. Use myMock := NewMockHelmer().")
}
params := []pegomock.Param{_param0}
result := pegomock.GetGenericMockFrom(mock).Invoke("RemoveRepo", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
var ret0 error
if len(result) != 0 {
if result[0] != nil {
ret0 = result[0].(error)
}
}
return ret0
}
func (mock *MockHelmer) RemoveRequirementsLock() error {
if mock == nil {
panic("mock must not be nil. Use myMock := NewMockHelmer().")
}
params := []pegomock.Param{}
result := pegomock.GetGenericMockFrom(mock).Invoke("RemoveRequirementsLock", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
var ret0 error
if len(result) != 0 {
if result[0] != nil {
ret0 = result[0].(error)
}
}
return ret0
}
func (mock *MockHelmer) SearchCharts(_param0 string, _param1 bool) ([]helm.ChartSummary, error) {
if mock == nil {
panic("mock must not be nil. Use myMock := NewMockHelmer().")
}
params := []pegomock.Param{_param0, _param1}
result := pegomock.GetGenericMockFrom(mock).Invoke("SearchCharts", params, []reflect.Type{reflect.TypeOf((*[]helm.ChartSummary)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
var ret0 []helm.ChartSummary
var ret1 error
if len(result) != 0 {
if result[0] != nil {
ret0 = result[0].([]helm.ChartSummary)
}
if result[1] != nil {
ret1 = result[1].(error)
}
}
return ret0, ret1
}
func (mock *MockHelmer) SetCWD(_param0 string) {
if mock == nil {
panic("mock must not be nil. Use myMock := NewMockHelmer().")
}
params := []pegomock.Param{_param0}
pegomock.GetGenericMockFrom(mock).Invoke("SetCWD", params, []reflect.Type{})
}
func (mock *MockHelmer) SetHelmBinary(_param0 string) {
if mock == nil {
panic("mock must not be nil. Use myMock := NewMockHelmer().")
}
params := []pegomock.Param{_param0}
pegomock.GetGenericMockFrom(mock).Invoke("SetHelmBinary", params, []reflect.Type{})
}
func (mock *MockHelmer) SetHost(_param0 string) {
if mock == nil {
panic("mock must not be nil. Use myMock := NewMockHelmer().")
}
params := []pegomock.Param{_param0}
pegomock.GetGenericMockFrom(mock).Invoke("SetHost", params, []reflect.Type{})
}
func (mock *MockHelmer) StatusRelease(_param0 string, _param1 string) error {
if mock == nil {
panic("mock must not be nil. Use myMock := NewMockHelmer().")
}
params := []pegomock.Param{_param0, _param1}
result := pegomock.GetGenericMockFrom(mock).Invoke("StatusRelease", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
var ret0 error
if len(result) != 0 {
if result[0] != nil {
ret0 = result[0].(error)
}
}
return ret0
}
func (mock *MockHelmer) StatusReleaseWithOutput(_param0 string, _param1 string, _param2 string) (string, error) {
if mock == nil {
panic("mock must not be nil. Use myMock := NewMockHelmer().")
}
params := []pegomock.Param{_param0, _param1, _param2}
result := pegomock.GetGenericMockFrom(mock).Invoke("StatusReleaseWithOutput", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
var ret0 string
var ret1 error
if len(result) != 0 {
if result[0] != nil {
ret0 = result[0].(string)
}
if result[1] != nil {
ret1 = result[1].(error)
}
}
return ret0, ret1
}
func (mock *MockHelmer) Template(_param0 string, _param1 string, _param2 string, _param3 string, _param4 bool, _param5 []string, _param6 []string) error {
if mock == nil {
panic("mock must not be nil. Use myMock := NewMockHelmer().")
}
params := []pegomock.Param{_param0, _param1, _param2, _param3, _param4, _param5, _param6}
result := pegomock.GetGenericMockFrom(mock).Invoke("Template", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
var ret0 error
if len(result) != 0 {
if result[0] != nil {
ret0 = result[0].(error)
}
}
return ret0
}
func (mock *MockHelmer) UpdateRepo() error {
if mock == nil {
panic("mock must not be nil. Use myMock := NewMockHelmer().")
}
params := []pegomock.Param{}
result := pegomock.GetGenericMockFrom(mock).Invoke("UpdateRepo", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
var ret0 error
if len(result) != 0 {
if result[0] != nil {
ret0 = result[0].(error)
}
}
return ret0
}
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) error {
if mock == nil {
panic("mock must not be nil. Use myMock := NewMockHelmer().")
}
params := []pegomock.Param{_param0, _param1, _param2, _param3, _param4, _param5, _param6, _param7, _param8, _param9, _param10, _param11, _param12}
result := pegomock.GetGenericMockFrom(mock).Invoke("UpgradeChart", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
var ret0 error
if len(result) != 0 {
if result[0] != nil {
ret0 = result[0].(error)
}
}
return ret0
}
func (mock *MockHelmer) Version(_param0 bool) (string, error) {
if mock == nil {
panic("mock must not be nil. Use myMock := NewMockHelmer().")
}
params := []pegomock.Param{_param0}
result := pegomock.GetGenericMockFrom(mock).Invoke("Version", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
var ret0 string
var ret1 error
if len(result) != 0 {
if result[0] != nil {
ret0 = result[0].(string)
}
if result[1] != nil {
ret1 = result[1].(error)
}
}
return ret0, ret1
}
func (mock *MockHelmer) VerifyWasCalledOnce() *VerifierMockHelmer {
return &VerifierMockHelmer{
mock: mock,
invocationCountMatcher: pegomock.Times(1),
}
}
func (mock *MockHelmer) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierMockHelmer {
return &VerifierMockHelmer{
mock: mock,
invocationCountMatcher: invocationCountMatcher,
}
}
func (mock *MockHelmer) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, inOrderContext *pegomock.InOrderContext) *VerifierMockHelmer {
return &VerifierMockHelmer{
mock: mock,
invocationCountMatcher: invocationCountMatcher,
inOrderContext: inOrderContext,
}
}
func (mock *MockHelmer) VerifyWasCalledEventually(invocationCountMatcher pegomock.Matcher, timeout time.Duration) *VerifierMockHelmer {
return &VerifierMockHelmer{
mock: mock,
invocationCountMatcher: invocationCountMatcher,
timeout: timeout,
}
}
type VerifierMockHelmer struct {
mock *MockHelmer
invocationCountMatcher pegomock.Matcher
inOrderContext *pegomock.InOrderContext
timeout time.Duration
}
func (verifier *VerifierMockHelmer) AddRepo(_param0 string, _param1 string, _param2 string, _param3 string) *MockHelmer_AddRepo_OngoingVerification {
params := []pegomock.Param{_param0, _param1, _param2, _param3}
methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "AddRepo", params, verifier.timeout)
return &MockHelmer_AddRepo_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}
type MockHelmer_AddRepo_OngoingVerification struct {
mock *MockHelmer
methodInvocations []pegomock.MethodInvocation
}
func (c *MockHelmer_AddRepo_OngoingVerification) GetCapturedArguments() (string, string, string, string) {
_param0, _param1, _param2, _param3 := c.GetAllCapturedArguments()
return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1], _param3[len(_param3)-1]
}
func (c *MockHelmer_AddRepo_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []string, _param3 []string) {
params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
if len(params) > 0 {
_param0 = make([]string, len(c.methodInvocations))
for u, param := range params[0] {
_param0[u] = param.(string)
}
_param1 = make([]string, len(c.methodInvocations))
for u, param := range params[1] {
_param1[u] = param.(string)
}
_param2 = make([]string, len(c.methodInvocations))
for u, param := range params[2] {
_param2[u] = param.(string)
}
_param3 = make([]string, len(c.methodInvocations))
for u, param := range params[3] {
_param3[u] = param.(string)
}
}
return
}
func (verifier *VerifierMockHelmer) BuildDependency() *MockHelmer_BuildDependency_OngoingVerification {
params := []pegomock.Param{}
methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "BuildDependency", params, verifier.timeout)
return &MockHelmer_BuildDependency_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}
type MockHelmer_BuildDependency_OngoingVerification struct {
mock *MockHelmer
methodInvocations []pegomock.MethodInvocation
}
func (c *MockHelmer_BuildDependency_OngoingVerification) GetCapturedArguments() {
}
func (c *MockHelmer_BuildDependency_OngoingVerification) GetAllCapturedArguments() {
}
func (verifier *VerifierMockHelmer) DecryptSecrets(_param0 string) *MockHelmer_DecryptSecrets_OngoingVerification {
params := []pegomock.Param{_param0}
methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "DecryptSecrets", params, verifier.timeout)
return &MockHelmer_DecryptSecrets_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}
type MockHelmer_DecryptSecrets_OngoingVerification struct {
mock *MockHelmer
methodInvocations []pegomock.MethodInvocation
}
func (c *MockHelmer_DecryptSecrets_OngoingVerification) GetCapturedArguments() string {
_param0 := c.GetAllCapturedArguments()
return _param0[len(_param0)-1]
}
func (c *MockHelmer_DecryptSecrets_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
if len(params) > 0 {
_param0 = make([]string, len(c.methodInvocations))
for u, param := range params[0] {
_param0[u] = param.(string)
}
}
return
}
func (verifier *VerifierMockHelmer) DeleteRelease(_param0 string, _param1 string, _param2 bool) *MockHelmer_DeleteRelease_OngoingVerification {
params := []pegomock.Param{_param0, _param1, _param2}
methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "DeleteRelease", params, verifier.timeout)
return &MockHelmer_DeleteRelease_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}
type MockHelmer_DeleteRelease_OngoingVerification struct {
mock *MockHelmer
methodInvocations []pegomock.MethodInvocation
}
func (c *MockHelmer_DeleteRelease_OngoingVerification) GetCapturedArguments() (string, string, bool) {
_param0, _param1, _param2 := c.GetAllCapturedArguments()
return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1]
}
func (c *MockHelmer_DeleteRelease_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []bool) {
params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
if len(params) > 0 {
_param0 = make([]string, len(c.methodInvocations))
for u, param := range params[0] {
_param0[u] = param.(string)
}
_param1 = make([]string, len(c.methodInvocations))
for u, param := range params[1] {
_param1[u] = param.(string)
}
_param2 = make([]bool, len(c.methodInvocations))
for u, param := range params[2] {
_param2[u] = param.(bool)
}
}
return
}
func (verifier *VerifierMockHelmer) Env() *MockHelmer_Env_OngoingVerification {
params := []pegomock.Param{}
methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Env", params, verifier.timeout)
return &MockHelmer_Env_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}
type MockHelmer_Env_OngoingVerification struct {
mock *MockHelmer
methodInvocations []pegomock.MethodInvocation
}
func (c *MockHelmer_Env_OngoingVerification) GetCapturedArguments() {
}
func (c *MockHelmer_Env_OngoingVerification) GetAllCapturedArguments() {
}
func (verifier *VerifierMockHelmer) FetchChart(_param0 string, _param1 string, _param2 bool, _param3 string, _param4 string, _param5 string, _param6 string) *MockHelmer_FetchChart_OngoingVerification {
params := []pegomock.Param{_param0, _param1, _param2, _param3, _param4, _param5, _param6}
methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "FetchChart", params, verifier.timeout)
return &MockHelmer_FetchChart_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}
type MockHelmer_FetchChart_OngoingVerification struct {
mock *MockHelmer
methodInvocations []pegomock.MethodInvocation
}
func (c *MockHelmer_FetchChart_OngoingVerification) GetCapturedArguments() (string, string, bool, string, string, string, string) {
_param0, _param1, _param2, _param3, _param4, _param5, _param6 := c.GetAllCapturedArguments()
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]
}
func (c *MockHelmer_FetchChart_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []bool, _param3 []string, _param4 []string, _param5 []string, _param6 []string) {
params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
if len(params) > 0 {
_param0 = make([]string, len(c.methodInvocations))
for u, param := range params[0] {
_param0[u] = param.(string)
}
_param1 = make([]string, len(c.methodInvocations))
for u, param := range params[1] {
_param1[u] = param.(string)
}
_param2 = make([]bool, len(c.methodInvocations))
for u, param := range params[2] {
_param2[u] = param.(bool)
}
_param3 = make([]string, len(c.methodInvocations))
for u, param := range params[3] {
_param3[u] = param.(string)
}
_param4 = make([]string, len(c.methodInvocations))
for u, param := range params[4] {
_param4[u] = param.(string)
}
_param5 = make([]string, len(c.methodInvocations))
for u, param := range params[5] {
_param5[u] = param.(string)
}
_param6 = make([]string, len(c.methodInvocations))
for u, param := range params[6] {
_param6[u] = param.(string)
}
}
return
}
func (verifier *VerifierMockHelmer) FindChart() *MockHelmer_FindChart_OngoingVerification {
params := []pegomock.Param{}
methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "FindChart", params, verifier.timeout)
return &MockHelmer_FindChart_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}
type MockHelmer_FindChart_OngoingVerification struct {
mock *MockHelmer
methodInvocations []pegomock.MethodInvocation
}
func (c *MockHelmer_FindChart_OngoingVerification) GetCapturedArguments() {
}
func (c *MockHelmer_FindChart_OngoingVerification) GetAllCapturedArguments() {
}
func (verifier *VerifierMockHelmer) HelmBinary() *MockHelmer_HelmBinary_OngoingVerification {
params := []pegomock.Param{}
methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "HelmBinary", params, verifier.timeout)
return &MockHelmer_HelmBinary_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}
type MockHelmer_HelmBinary_OngoingVerification struct {
mock *MockHelmer
methodInvocations []pegomock.MethodInvocation
}
func (c *MockHelmer_HelmBinary_OngoingVerification) GetCapturedArguments() {
}
func (c *MockHelmer_HelmBinary_OngoingVerification) GetAllCapturedArguments() {
}
func (verifier *VerifierMockHelmer) Init(_param0 bool, _param1 string, _param2 string, _param3 bool) *MockHelmer_Init_OngoingVerification {
params := []pegomock.Param{_param0, _param1, _param2, _param3}
methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Init", params, verifier.timeout)
return &MockHelmer_Init_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}
type MockHelmer_Init_OngoingVerification struct {
mock *MockHelmer
methodInvocations []pegomock.MethodInvocation
}
func (c *MockHelmer_Init_OngoingVerification) GetCapturedArguments() (bool, string, string, bool) {
_param0, _param1, _param2, _param3 := c.GetAllCapturedArguments()
return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1], _param3[len(_param3)-1]
}
func (c *MockHelmer_Init_OngoingVerification) GetAllCapturedArguments() (_param0 []bool, _param1 []string, _param2 []string, _param3 []bool) {
params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
if len(params) > 0 {
_param0 = make([]bool, len(c.methodInvocations))
for u, param := range params[0] {
_param0[u] = param.(bool)
}
_param1 = make([]string, len(c.methodInvocations))
for u, param := range params[1] {
_param1[u] = param.(string)
}
_param2 = make([]string, len(c.methodInvocations))
for u, param := range params[2] {
_param2[u] = param.(string)
}
_param3 = make([]bool, len(c.methodInvocations))
for u, param := range params[3] {
_param3[u] = param.(bool)
}
}
return
}
func (verifier *VerifierMockHelmer) InstallChart(_param0 string, _param1 string, _param2 string, _param3 string, _param4 int, _param5 []string, _param6 []string, _param7 string, _param8 string, _param9 string) *MockHelmer_InstallChart_OngoingVerification {
params := []pegomock.Param{_param0, _param1, _param2, _param3, _param4, _param5, _param6, _param7, _param8, _param9}
methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "InstallChart", params, verifier.timeout)
return &MockHelmer_InstallChart_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}
type MockHelmer_InstallChart_OngoingVerification struct {
mock *MockHelmer
methodInvocations []pegomock.MethodInvocation
}
func (c *MockHelmer_InstallChart_OngoingVerification) GetCapturedArguments() (string, string, string, string, int, []string, []string, string, string, string) {
_param0, _param1, _param2, _param3, _param4, _param5, _param6, _param7, _param8, _param9 := c.GetAllCapturedArguments()
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]
}
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) {
params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
if len(params) > 0 {
_param0 = make([]string, len(c.methodInvocations))
for u, param := range params[0] {
_param0[u] = param.(string)
}
_param1 = make([]string, len(c.methodInvocations))
for u, param := range params[1] {
_param1[u] = param.(string)
}
_param2 = make([]string, len(c.methodInvocations))
for u, param := range params[2] {
_param2[u] = param.(string)
}
_param3 = make([]string, len(c.methodInvocations))
for u, param := range params[3] {
_param3[u] = param.(string)
}
_param4 = make([]int, len(c.methodInvocations))
for u, param := range params[4] {
_param4[u] = param.(int)
}
_param5 = make([][]string, len(c.methodInvocations))
for u, param := range params[5] {
_param5[u] = param.([]string)
}
_param6 = make([][]string, len(c.methodInvocations))
for u, param := range params[6] {
_param6[u] = param.([]string)
}
_param7 = make([]string, len(c.methodInvocations))
for u, param := range params[7] {
_param7[u] = param.(string)
}
_param8 = make([]string, len(c.methodInvocations))
for u, param := range params[8] {
_param8[u] = param.(string)
}
_param9 = make([]string, len(c.methodInvocations))
for u, param := range params[9] {
_param9[u] = param.(string)
}
}
return
}
func (verifier *VerifierMockHelmer) IsRepoMissing(_param0 string) *MockHelmer_IsRepoMissing_OngoingVerification {
params := []pegomock.Param{_param0}
methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "IsRepoMissing", params, verifier.timeout)
return &MockHelmer_IsRepoMissing_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}
type MockHelmer_IsRepoMissing_OngoingVerification struct {
mock *MockHelmer
methodInvocations []pegomock.MethodInvocation
}
func (c *MockHelmer_IsRepoMissing_OngoingVerification) GetCapturedArguments() string {
_param0 := c.GetAllCapturedArguments()
return _param0[len(_param0)-1]
}
func (c *MockHelmer_IsRepoMissing_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
if len(params) > 0 {
_param0 = make([]string, len(c.methodInvocations))
for u, param := range params[0] {
_param0[u] = param.(string)
}
}
return
}
func (verifier *VerifierMockHelmer) Lint(_param0 []string) *MockHelmer_Lint_OngoingVerification {
params := []pegomock.Param{_param0}
methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Lint", params, verifier.timeout)
return &MockHelmer_Lint_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}
type MockHelmer_Lint_OngoingVerification struct {
mock *MockHelmer
methodInvocations []pegomock.MethodInvocation
}
func (c *MockHelmer_Lint_OngoingVerification) GetCapturedArguments() []string {
_param0 := c.GetAllCapturedArguments()
return _param0[len(_param0)-1]
}
func (c *MockHelmer_Lint_OngoingVerification) GetAllCapturedArguments() (_param0 [][]string) {
params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
if len(params) > 0 {
_param0 = make([][]string, len(c.methodInvocations))
for u, param := range params[0] {
_param0[u] = param.([]string)
}
}
return
}
func (verifier *VerifierMockHelmer) ListReleases(_param0 string) *MockHelmer_ListReleases_OngoingVerification {
params := []pegomock.Param{_param0}
methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ListReleases", params, verifier.timeout)
return &MockHelmer_ListReleases_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}
type MockHelmer_ListReleases_OngoingVerification struct {
mock *MockHelmer
methodInvocations []pegomock.MethodInvocation
}
func (c *MockHelmer_ListReleases_OngoingVerification) GetCapturedArguments() string {
_param0 := c.GetAllCapturedArguments()
return _param0[len(_param0)-1]
}
func (c *MockHelmer_ListReleases_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
if len(params) > 0 {
_param0 = make([]string, len(c.methodInvocations))
for u, param := range params[0] {
_param0[u] = param.(string)
}
}
return
}
func (verifier *VerifierMockHelmer) ListRepos() *MockHelmer_ListRepos_OngoingVerification {
params := []pegomock.Param{}
methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ListRepos", params, verifier.timeout)
return &MockHelmer_ListRepos_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}
type MockHelmer_ListRepos_OngoingVerification struct {
mock *MockHelmer
methodInvocations []pegomock.MethodInvocation
}
func (c *MockHelmer_ListRepos_OngoingVerification) GetCapturedArguments() {
}
func (c *MockHelmer_ListRepos_OngoingVerification) GetAllCapturedArguments() {
}
func (verifier *VerifierMockHelmer) PackageChart() *MockHelmer_PackageChart_OngoingVerification {
params := []pegomock.Param{}
methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "PackageChart", params, verifier.timeout)
return &MockHelmer_PackageChart_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}
type MockHelmer_PackageChart_OngoingVerification struct {
mock *MockHelmer
methodInvocations []pegomock.MethodInvocation
}
func (c *MockHelmer_PackageChart_OngoingVerification) GetCapturedArguments() {
}
func (c *MockHelmer_PackageChart_OngoingVerification) GetAllCapturedArguments() {
}
func (verifier *VerifierMockHelmer) RemoveRepo(_param0 string) *MockHelmer_RemoveRepo_OngoingVerification {
params := []pegomock.Param{_param0}
methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "RemoveRepo", params, verifier.timeout)
return &MockHelmer_RemoveRepo_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}
type MockHelmer_RemoveRepo_OngoingVerification struct {
mock *MockHelmer
methodInvocations []pegomock.MethodInvocation
}
func (c *MockHelmer_RemoveRepo_OngoingVerification) GetCapturedArguments() string {
_param0 := c.GetAllCapturedArguments()
return _param0[len(_param0)-1]
}
func (c *MockHelmer_RemoveRepo_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
if len(params) > 0 {
_param0 = make([]string, len(c.methodInvocations))
for u, param := range params[0] {
_param0[u] = param.(string)
}
}
return
}
func (verifier *VerifierMockHelmer) RemoveRequirementsLock() *MockHelmer_RemoveRequirementsLock_OngoingVerification {
params := []pegomock.Param{}
methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "RemoveRequirementsLock", params, verifier.timeout)
return &MockHelmer_RemoveRequirementsLock_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}
type MockHelmer_RemoveRequirementsLock_OngoingVerification struct {
mock *MockHelmer
methodInvocations []pegomock.MethodInvocation
}
func (c *MockHelmer_RemoveRequirementsLock_OngoingVerification) GetCapturedArguments() {
}
func (c *MockHelmer_RemoveRequirementsLock_OngoingVerification) GetAllCapturedArguments() {
}
func (verifier *VerifierMockHelmer) SearchCharts(_param0 string, _param1 bool) *MockHelmer_SearchCharts_OngoingVerification {
params := []pegomock.Param{_param0, _param1}
methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "SearchCharts", params, verifier.timeout)
return &MockHelmer_SearchCharts_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}
type MockHelmer_SearchCharts_OngoingVerification struct {
mock *MockHelmer
methodInvocations []pegomock.MethodInvocation
}
func (c *MockHelmer_SearchCharts_OngoingVerification) GetCapturedArguments() (string, bool) {
_param0, _param1 := c.GetAllCapturedArguments()
return _param0[len(_param0)-1], _param1[len(_param1)-1]
}
func (c *MockHelmer_SearchCharts_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []bool) {
params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
if len(params) > 0 {
_param0 = make([]string, len(c.methodInvocations))
for u, param := range params[0] {
_param0[u] = param.(string)
}
_param1 = make([]bool, len(c.methodInvocations))
for u, param := range params[1] {
_param1[u] = param.(bool)
}
}
return
}
func (verifier *VerifierMockHelmer) SetCWD(_param0 string) *MockHelmer_SetCWD_OngoingVerification {
params := []pegomock.Param{_param0}
methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "SetCWD", params, verifier.timeout)
return &MockHelmer_SetCWD_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}
type MockHelmer_SetCWD_OngoingVerification struct {
mock *MockHelmer
methodInvocations []pegomock.MethodInvocation
}
func (c *MockHelmer_SetCWD_OngoingVerification) GetCapturedArguments() string {
_param0 := c.GetAllCapturedArguments()
return _param0[len(_param0)-1]
}
func (c *MockHelmer_SetCWD_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
if len(params) > 0 {
_param0 = make([]string, len(c.methodInvocations))
for u, param := range params[0] {
_param0[u] = param.(string)
}
}
return
}
func (verifier *VerifierMockHelmer) SetHelmBinary(_param0 string) *MockHelmer_SetHelmBinary_OngoingVerification {
params := []pegomock.Param{_param0}
methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "SetHelmBinary", params, verifier.timeout)
return &MockHelmer_SetHelmBinary_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}
type MockHelmer_SetHelmBinary_OngoingVerification struct {
mock *MockHelmer
methodInvocations []pegomock.MethodInvocation
}
func (c *MockHelmer_SetHelmBinary_OngoingVerification) GetCapturedArguments() string {
_param0 := c.GetAllCapturedArguments()
return _param0[len(_param0)-1]
}
func (c *MockHelmer_SetHelmBinary_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
if len(params) > 0 {
_param0 = make([]string, len(c.methodInvocations))
for u, param := range params[0] {
_param0[u] = param.(string)
}
}
return
}
func (verifier *VerifierMockHelmer) SetHost(_param0 string) *MockHelmer_SetHost_OngoingVerification {
params := []pegomock.Param{_param0}
methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "SetHost", params, verifier.timeout)
return &MockHelmer_SetHost_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}
type MockHelmer_SetHost_OngoingVerification struct {
mock *MockHelmer
methodInvocations []pegomock.MethodInvocation
}
func (c *MockHelmer_SetHost_OngoingVerification) GetCapturedArguments() string {
_param0 := c.GetAllCapturedArguments()
return _param0[len(_param0)-1]
}
func (c *MockHelmer_SetHost_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
if len(params) > 0 {
_param0 = make([]string, len(c.methodInvocations))
for u, param := range params[0] {
_param0[u] = param.(string)
}
}
return
}
func (verifier *VerifierMockHelmer) StatusRelease(_param0 string, _param1 string) *MockHelmer_StatusRelease_OngoingVerification {
params := []pegomock.Param{_param0, _param1}
methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "StatusRelease", params, verifier.timeout)
return &MockHelmer_StatusRelease_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}
type MockHelmer_StatusRelease_OngoingVerification struct {
mock *MockHelmer
methodInvocations []pegomock.MethodInvocation
}
func (c *MockHelmer_StatusRelease_OngoingVerification) GetCapturedArguments() (string, string) {
_param0, _param1 := c.GetAllCapturedArguments()
return _param0[len(_param0)-1], _param1[len(_param1)-1]
}
func (c *MockHelmer_StatusRelease_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
if len(params) > 0 {
_param0 = make([]string, len(c.methodInvocations))
for u, param := range params[0] {
_param0[u] = param.(string)
}
_param1 = make([]string, len(c.methodInvocations))
for u, param := range params[1] {
_param1[u] = param.(string)
}
}
return
}
func (verifier *VerifierMockHelmer) StatusReleaseWithOutput(_param0 string, _param1 string, _param2 string) *MockHelmer_StatusReleaseWithOutput_OngoingVerification {
params := []pegomock.Param{_param0, _param1, _param2}
methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "StatusReleaseWithOutput", params, verifier.timeout)
return &MockHelmer_StatusReleaseWithOutput_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}
type MockHelmer_StatusReleaseWithOutput_OngoingVerification struct {
mock *MockHelmer
methodInvocations []pegomock.MethodInvocation
}
func (c *MockHelmer_StatusReleaseWithOutput_OngoingVerification) GetCapturedArguments() (string, string, string) {
_param0, _param1, _param2 := c.GetAllCapturedArguments()
return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1]
}
func (c *MockHelmer_StatusReleaseWithOutput_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []string) {
params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
if len(params) > 0 {
_param0 = make([]string, len(c.methodInvocations))
for u, param := range params[0] {
_param0[u] = param.(string)
}
_param1 = make([]string, len(c.methodInvocations))
for u, param := range params[1] {
_param1[u] = param.(string)
}
_param2 = make([]string, len(c.methodInvocations))
for u, param := range params[2] {
_param2[u] = param.(string)
}
}
return
}
func (verifier *VerifierMockHelmer) Template(_param0 string, _param1 string, _param2 string, _param3 string, _param4 bool, _param5 []string, _param6 []string) *MockHelmer_Template_OngoingVerification {
params := []pegomock.Param{_param0, _param1, _param2, _param3, _param4, _param5, _param6}
methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Template", params, verifier.timeout)
return &MockHelmer_Template_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}
type MockHelmer_Template_OngoingVerification struct {
mock *MockHelmer
methodInvocations []pegomock.MethodInvocation
}
func (c *MockHelmer_Template_OngoingVerification) GetCapturedArguments() (string, string, string, string, bool, []string, []string) {
_param0, _param1, _param2, _param3, _param4, _param5, _param6 := c.GetAllCapturedArguments()
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]
}
func (c *MockHelmer_Template_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []string, _param3 []string, _param4 []bool, _param5 [][]string, _param6 [][]string) {
params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
if len(params) > 0 {
_param0 = make([]string, len(c.methodInvocations))
for u, param := range params[0] {
_param0[u] = param.(string)
}
_param1 = make([]string, len(c.methodInvocations))
for u, param := range params[1] {
_param1[u] = param.(string)
}
_param2 = make([]string, len(c.methodInvocations))
for u, param := range params[2] {
_param2[u] = param.(string)
}
_param3 = make([]string, len(c.methodInvocations))
for u, param := range params[3] {
_param3[u] = param.(string)
}
_param4 = make([]bool, len(c.methodInvocations))
for u, param := range params[4] {
_param4[u] = param.(bool)
}
_param5 = make([][]string, len(c.methodInvocations))
for u, param := range params[5] {
_param5[u] = param.([]string)
}
_param6 = make([][]string, len(c.methodInvocations))
for u, param := range params[6] {
_param6[u] = param.([]string)
}
}
return
}
func (verifier *VerifierMockHelmer) UpdateRepo() *MockHelmer_UpdateRepo_OngoingVerification {
params := []pegomock.Param{}
methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "UpdateRepo", params, verifier.timeout)
return &MockHelmer_UpdateRepo_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}
type MockHelmer_UpdateRepo_OngoingVerification struct {
mock *MockHelmer
methodInvocations []pegomock.MethodInvocation
}
func (c *MockHelmer_UpdateRepo_OngoingVerification) GetCapturedArguments() {
}
func (c *MockHelmer_UpdateRepo_OngoingVerification) GetAllCapturedArguments() {
}
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) *MockHelmer_UpgradeChart_OngoingVerification {
params := []pegomock.Param{_param0, _param1, _param2, _param3, _param4, _param5, _param6, _param7, _param8, _param9, _param10, _param11, _param12}
methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "UpgradeChart", params, verifier.timeout)
return &MockHelmer_UpgradeChart_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}
type MockHelmer_UpgradeChart_OngoingVerification struct {
mock *MockHelmer
methodInvocations []pegomock.MethodInvocation
}
func (c *MockHelmer_UpgradeChart_OngoingVerification) GetCapturedArguments() (string, string, string, string, bool, int, bool, bool, []string, []string, string, string, string) {
_param0, _param1, _param2, _param3, _param4, _param5, _param6, _param7, _param8, _param9, _param10, _param11, _param12 := c.GetAllCapturedArguments()
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]
}
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) {
params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
if len(params) > 0 {
_param0 = make([]string, len(c.methodInvocations))
for u, param := range params[0] {
_param0[u] = param.(string)
}
_param1 = make([]string, len(c.methodInvocations))
for u, param := range params[1] {
_param1[u] = param.(string)
}
_param2 = make([]string, len(c.methodInvocations))
for u, param := range params[2] {
_param2[u] = param.(string)
}
_param3 = make([]string, len(c.methodInvocations))
for u, param := range params[3] {
_param3[u] = param.(string)
}
_param4 = make([]bool, len(c.methodInvocations))
for u, param := range params[4] {
_param4[u] = param.(bool)
}
_param5 = make([]int, len(c.methodInvocations))
for u, param := range params[5] {
_param5[u] = param.(int)
}
_param6 = make([]bool, len(c.methodInvocations))
for u, param := range params[6] {
_param6[u] = param.(bool)
}
_param7 = make([]bool, len(c.methodInvocations))
for u, param := range params[7] {
_param7[u] = param.(bool)
}
_param8 = make([][]string, len(c.methodInvocations))
for u, param := range params[8] {
_param8[u] = param.([]string)
}
_param9 = make([][]string, len(c.methodInvocations))
for u, param := range params[9] {
_param9[u] = param.([]string)
}
_param10 = make([]string, len(c.methodInvocations))
for u, param := range params[10] {
_param10[u] = param.(string)
}
_param11 = make([]string, len(c.methodInvocations))
for u, param := range params[11] {
_param11[u] = param.(string)
}
_param12 = make([]string, len(c.methodInvocations))
for u, param := range params[12] {
_param12[u] = param.(string)
}
}
return
}
func (verifier *VerifierMockHelmer) Version(_param0 bool) *MockHelmer_Version_OngoingVerification {
params := []pegomock.Param{_param0}
methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Version", params, verifier.timeout)
return &MockHelmer_Version_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}
type MockHelmer_Version_OngoingVerification struct {
mock *MockHelmer
methodInvocations []pegomock.MethodInvocation
}
func (c *MockHelmer_Version_OngoingVerification) GetCapturedArguments() bool {
_param0 := c.GetAllCapturedArguments()
return _param0[len(_param0)-1]
}
func (c *MockHelmer_Version_OngoingVerification) GetAllCapturedArguments() (_param0 []bool) {
params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
if len(params) > 0 {
_param0 = make([]bool, len(c.methodInvocations))
for u, param := range params[0] {
_param0[u] = param.(bool)
}
}
return
}
You can’t perform that action at this time.