helmer.go

// Code generated by pegomock. DO NOT EDIT.
// Source: github.com/jenkins-x/jx/pkg/helm (interfaces: Helmer)

package helm_test

import (
	helm "github.com/jenkins-x/jx/pkg/helm"
	pegomock "github.com/petergtz/pegomock"
	"reflect"
)

type MockHelmer struct {
	fail func(message string, callerSkip ...int)
}

func NewMockHelmer() *MockHelmer {
	return &MockHelmer{fail: pegomock.GlobalFailHandler}
}

func (mock *MockHelmer) AddRepo(_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("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) DeleteRelease(_param0 string, _param1 bool) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockHelmer().")
	}
	params := []pegomock.Param{_param0, _param1}
	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) 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) 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("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, 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((*error)(nil)).Elem()})
	var ret0 bool
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(bool)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockHelmer) Lint() (string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockHelmer().")
	}
	params := []pegomock.Param{}
	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) ListCharts() (string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockHelmer().")
	}
	params := []pegomock.Param{}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ListCharts", 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) 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) SearchChartVersions(_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("SearchChartVersions", 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) SearchCharts(_param0 string) ([]helm.ChartSummary, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockHelmer().")
	}
	params := []pegomock.Param{_param0}
	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) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockHelmer().")
	}
	params := []pegomock.Param{_param0}
	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) StatusReleases() (map[string]string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockHelmer().")
	}
	params := []pegomock.Param{}
	result := pegomock.GetGenericMockFrom(mock).Invoke("StatusReleases", 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) 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) 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("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() *VerifierHelmer {
	return &VerifierHelmer{mock, pegomock.Times(1), nil}
}

func (mock *MockHelmer) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierHelmer {
	return &VerifierHelmer{mock, invocationCountMatcher, nil}
}

func (mock *MockHelmer) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, inOrderContext *pegomock.InOrderContext) *VerifierHelmer {
	return &VerifierHelmer{mock, invocationCountMatcher, inOrderContext}
}

type VerifierHelmer struct {
	mock                   *MockHelmer
	invocationCountMatcher pegomock.Matcher
	inOrderContext         *pegomock.InOrderContext
}

func (verifier *VerifierHelmer) AddRepo(_param0 string, _param1 string) *Helmer_AddRepo_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "AddRepo", params)
	return &Helmer_AddRepo_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_AddRepo_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_AddRepo_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *Helmer_AddRepo_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierHelmer) BuildDependency() *Helmer_BuildDependency_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "BuildDependency", params)
	return &Helmer_BuildDependency_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_BuildDependency_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_BuildDependency_OngoingVerification) GetCapturedArguments() {
}

func (c *Helmer_BuildDependency_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierHelmer) DeleteRelease(_param0 string, _param1 bool) *Helmer_DeleteRelease_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "DeleteRelease", params)
	return &Helmer_DeleteRelease_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_DeleteRelease_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_DeleteRelease_OngoingVerification) GetCapturedArguments() (string, bool) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *Helmer_DeleteRelease_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []bool) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]bool, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(bool)
		}
	}
	return
}

func (verifier *VerifierHelmer) Env() *Helmer_Env_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Env", params)
	return &Helmer_Env_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_Env_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_Env_OngoingVerification) GetCapturedArguments() {
}

func (c *Helmer_Env_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierHelmer) FindChart() *Helmer_FindChart_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "FindChart", params)
	return &Helmer_FindChart_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_FindChart_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_FindChart_OngoingVerification) GetCapturedArguments() {
}

func (c *Helmer_FindChart_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierHelmer) HelmBinary() *Helmer_HelmBinary_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "HelmBinary", params)
	return &Helmer_HelmBinary_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_HelmBinary_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_HelmBinary_OngoingVerification) GetCapturedArguments() {
}

func (c *Helmer_HelmBinary_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierHelmer) Init(_param0 bool, _param1 string, _param2 string, _param3 bool) *Helmer_Init_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2, _param3}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Init", params)
	return &Helmer_Init_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_Init_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_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 *Helmer_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(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(bool)
		}
		_param1 = make([]string, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([]string, len(params[2]))
		for u, param := range params[2] {
			_param2[u] = param.(string)
		}
		_param3 = make([]bool, len(params[3]))
		for u, param := range params[3] {
			_param3[u] = param.(bool)
		}
	}
	return
}

func (verifier *VerifierHelmer) InstallChart(_param0 string, _param1 string, _param2 string, _param3 *string, _param4 *int, _param5 []string, _param6 []string) *Helmer_InstallChart_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2, _param3, _param4, _param5, _param6}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "InstallChart", params)
	return &Helmer_InstallChart_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_InstallChart_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_InstallChart_OngoingVerification) GetCapturedArguments() (string, string, string, *string, *int, []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 *Helmer_InstallChart_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []string, _param3 []*string, _param4 []*int, _param5 [][]string, _param6 [][]string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([]string, len(params[2]))
		for u, param := range params[2] {
			_param2[u] = param.(string)
		}
		_param3 = make([]*string, len(params[3]))
		for u, param := range params[3] {
			_param3[u] = param.(*string)
		}
		_param4 = make([]*int, len(params[4]))
		for u, param := range params[4] {
			_param4[u] = param.(*int)
		}
		_param5 = make([][]string, len(params[5]))
		for u, param := range params[5] {
			_param5[u] = param.([]string)
		}
		_param6 = make([][]string, len(params[6]))
		for u, param := range params[6] {
			_param6[u] = param.([]string)
		}
	}
	return
}

func (verifier *VerifierHelmer) IsRepoMissing(_param0 string) *Helmer_IsRepoMissing_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "IsRepoMissing", params)
	return &Helmer_IsRepoMissing_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_IsRepoMissing_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_IsRepoMissing_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *Helmer_IsRepoMissing_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierHelmer) Lint() *Helmer_Lint_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Lint", params)
	return &Helmer_Lint_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_Lint_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_Lint_OngoingVerification) GetCapturedArguments() {
}

func (c *Helmer_Lint_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierHelmer) ListCharts() *Helmer_ListCharts_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ListCharts", params)
	return &Helmer_ListCharts_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_ListCharts_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_ListCharts_OngoingVerification) GetCapturedArguments() {
}

func (c *Helmer_ListCharts_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierHelmer) ListRepos() *Helmer_ListRepos_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ListRepos", params)
	return &Helmer_ListRepos_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_ListRepos_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_ListRepos_OngoingVerification) GetCapturedArguments() {
}

func (c *Helmer_ListRepos_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierHelmer) PackageChart() *Helmer_PackageChart_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "PackageChart", params)
	return &Helmer_PackageChart_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_PackageChart_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_PackageChart_OngoingVerification) GetCapturedArguments() {
}

func (c *Helmer_PackageChart_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierHelmer) RemoveRepo(_param0 string) *Helmer_RemoveRepo_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "RemoveRepo", params)
	return &Helmer_RemoveRepo_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_RemoveRepo_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_RemoveRepo_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *Helmer_RemoveRepo_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierHelmer) RemoveRequirementsLock() *Helmer_RemoveRequirementsLock_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "RemoveRequirementsLock", params)
	return &Helmer_RemoveRequirementsLock_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_RemoveRequirementsLock_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_RemoveRequirementsLock_OngoingVerification) GetCapturedArguments() {
}

func (c *Helmer_RemoveRequirementsLock_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierHelmer) SearchChartVersions(_param0 string) *Helmer_SearchChartVersions_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "SearchChartVersions", params)
	return &Helmer_SearchChartVersions_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_SearchChartVersions_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_SearchChartVersions_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *Helmer_SearchChartVersions_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierHelmer) SearchCharts(_param0 string) *Helmer_SearchCharts_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "SearchCharts", params)
	return &Helmer_SearchCharts_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_SearchCharts_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_SearchCharts_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *Helmer_SearchCharts_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierHelmer) SetCWD(_param0 string) *Helmer_SetCWD_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "SetCWD", params)
	return &Helmer_SetCWD_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_SetCWD_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_SetCWD_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *Helmer_SetCWD_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierHelmer) SetHelmBinary(_param0 string) *Helmer_SetHelmBinary_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "SetHelmBinary", params)
	return &Helmer_SetHelmBinary_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_SetHelmBinary_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_SetHelmBinary_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *Helmer_SetHelmBinary_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierHelmer) SetHost(_param0 string) *Helmer_SetHost_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "SetHost", params)
	return &Helmer_SetHost_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_SetHost_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_SetHost_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *Helmer_SetHost_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierHelmer) StatusRelease(_param0 string) *Helmer_StatusRelease_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "StatusRelease", params)
	return &Helmer_StatusRelease_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_StatusRelease_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_StatusRelease_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *Helmer_StatusRelease_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierHelmer) StatusReleases() *Helmer_StatusReleases_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "StatusReleases", params)
	return &Helmer_StatusReleases_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_StatusReleases_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_StatusReleases_OngoingVerification) GetCapturedArguments() {
}

func (c *Helmer_StatusReleases_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierHelmer) UpdateRepo() *Helmer_UpdateRepo_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "UpdateRepo", params)
	return &Helmer_UpdateRepo_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_UpdateRepo_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_UpdateRepo_OngoingVerification) GetCapturedArguments() {
}

func (c *Helmer_UpdateRepo_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierHelmer) UpgradeChart(_param0 string, _param1 string, _param2 string, _param3 *string, _param4 bool, _param5 *int, _param6 bool, _param7 bool, _param8 []string, _param9 []string) *Helmer_UpgradeChart_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2, _param3, _param4, _param5, _param6, _param7, _param8, _param9}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "UpgradeChart", params)
	return &Helmer_UpgradeChart_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_UpgradeChart_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_UpgradeChart_OngoingVerification) GetCapturedArguments() (string, string, string, *string, bool, *int, bool, bool, []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 *Helmer_UpgradeChart_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []string, _param3 []*string, _param4 []bool, _param5 []*int, _param6 []bool, _param7 []bool, _param8 [][]string, _param9 [][]string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([]string, len(params[2]))
		for u, param := range params[2] {
			_param2[u] = param.(string)
		}
		_param3 = make([]*string, len(params[3]))
		for u, param := range params[3] {
			_param3[u] = param.(*string)
		}
		_param4 = make([]bool, len(params[4]))
		for u, param := range params[4] {
			_param4[u] = param.(bool)
		}
		_param5 = make([]*int, len(params[5]))
		for u, param := range params[5] {
			_param5[u] = param.(*int)
		}
		_param6 = make([]bool, len(params[6]))
		for u, param := range params[6] {
			_param6[u] = param.(bool)
		}
		_param7 = make([]bool, len(params[7]))
		for u, param := range params[7] {
			_param7[u] = param.(bool)
		}
		_param8 = make([][]string, len(params[8]))
		for u, param := range params[8] {
			_param8[u] = param.([]string)
		}
		_param9 = make([][]string, len(params[9]))
		for u, param := range params[9] {
			_param9[u] = param.([]string)
		}
	}
	return
}

func (verifier *VerifierHelmer) Version(_param0 bool) *Helmer_Version_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Version", params)
	return &Helmer_Version_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_Version_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_Version_OngoingVerification) GetCapturedArguments() bool {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *Helmer_Version_OngoingVerification) GetAllCapturedArguments() (_param0 []bool) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]bool, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(bool)
		}
	}
	return
}