github.com/jenkins-x/jx/v2@v2.1.155/pkg/versionstream/mocks/streamer.go

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

package versionstream_test

import (
	"reflect"
	"time"

	versionstream "github.com/jenkins-x/jx/v2/pkg/versionstream"
	pegomock "github.com/petergtz/pegomock"
)

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

func NewMockStreamer(options ...pegomock.Option) *MockStreamer {
	mock := &MockStreamer{}
	for _, option := range options {
		option.Apply(mock)
	}
	return mock
}

func (mock *MockStreamer) SetFailHandler(fh pegomock.FailHandler) { mock.fail = fh }
func (mock *MockStreamer) FailHandler() pegomock.FailHandler      { return mock.fail }

func (mock *MockStreamer) GetRepositoryPrefixes() (*versionstream.RepositoryPrefixes, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockStreamer().")
	}
	params := []pegomock.Param{}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetRepositoryPrefixes", params, []reflect.Type{reflect.TypeOf((**versionstream.RepositoryPrefixes)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 *versionstream.RepositoryPrefixes
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(*versionstream.RepositoryPrefixes)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockStreamer) GetVersionsDir() string {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockStreamer().")
	}
	params := []pegomock.Param{}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetVersionsDir", 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 *MockStreamer) ResolveDockerImage(_param0 string) (string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockStreamer().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ResolveDockerImage", 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 *MockStreamer) ResolveGitVersion(_param0 string) (string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockStreamer().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ResolveGitVersion", 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 *MockStreamer) StableVersion(_param0 versionstream.VersionKind, _param1 string) (*versionstream.StableVersion, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockStreamer().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("StableVersion", params, []reflect.Type{reflect.TypeOf((**versionstream.StableVersion)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 *versionstream.StableVersion
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(*versionstream.StableVersion)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockStreamer) StableVersionNumber(_param0 versionstream.VersionKind, _param1 string) (string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockStreamer().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("StableVersionNumber", 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 *MockStreamer) VerifyPackage(_param0 string, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockStreamer().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("VerifyPackage", 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 *MockStreamer) VerifyPackages(_param0 map[string]string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockStreamer().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("VerifyPackages", 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 *MockStreamer) VerifyWasCalledOnce() *VerifierMockStreamer {
	return &VerifierMockStreamer{
		mock:                   mock,
		invocationCountMatcher: pegomock.Times(1),
	}
}

func (mock *MockStreamer) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierMockStreamer {
	return &VerifierMockStreamer{
		mock:                   mock,
		invocationCountMatcher: invocationCountMatcher,
	}
}

func (mock *MockStreamer) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, inOrderContext *pegomock.InOrderContext) *VerifierMockStreamer {
	return &VerifierMockStreamer{
		mock:                   mock,
		invocationCountMatcher: invocationCountMatcher,
		inOrderContext:         inOrderContext,
	}
}

func (mock *MockStreamer) VerifyWasCalledEventually(invocationCountMatcher pegomock.Matcher, timeout time.Duration) *VerifierMockStreamer {
	return &VerifierMockStreamer{
		mock:                   mock,
		invocationCountMatcher: invocationCountMatcher,
		timeout:                timeout,
	}
}

type VerifierMockStreamer struct {
	mock                   *MockStreamer
	invocationCountMatcher pegomock.Matcher
	inOrderContext         *pegomock.InOrderContext
	timeout                time.Duration
}

func (verifier *VerifierMockStreamer) GetRepositoryPrefixes() *MockStreamer_GetRepositoryPrefixes_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetRepositoryPrefixes", params, verifier.timeout)
	return &MockStreamer_GetRepositoryPrefixes_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockStreamer_GetRepositoryPrefixes_OngoingVerification struct {
	mock              *MockStreamer
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockStreamer_GetRepositoryPrefixes_OngoingVerification) GetCapturedArguments() {
}

func (c *MockStreamer_GetRepositoryPrefixes_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierMockStreamer) GetVersionsDir() *MockStreamer_GetVersionsDir_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetVersionsDir", params, verifier.timeout)
	return &MockStreamer_GetVersionsDir_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockStreamer_GetVersionsDir_OngoingVerification struct {
	mock              *MockStreamer
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockStreamer_GetVersionsDir_OngoingVerification) GetCapturedArguments() {
}

func (c *MockStreamer_GetVersionsDir_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierMockStreamer) ResolveDockerImage(_param0 string) *MockStreamer_ResolveDockerImage_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ResolveDockerImage", params, verifier.timeout)
	return &MockStreamer_ResolveDockerImage_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockStreamer_ResolveDockerImage_OngoingVerification struct {
	mock              *MockStreamer
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockStreamer_ResolveDockerImage_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 *VerifierMockStreamer) ResolveGitVersion(_param0 string) *MockStreamer_ResolveGitVersion_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ResolveGitVersion", params, verifier.timeout)
	return &MockStreamer_ResolveGitVersion_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockStreamer_ResolveGitVersion_OngoingVerification struct {
	mock              *MockStreamer
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockStreamer_ResolveGitVersion_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 *VerifierMockStreamer) StableVersion(_param0 versionstream.VersionKind, _param1 string) *MockStreamer_StableVersion_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "StableVersion", params, verifier.timeout)
	return &MockStreamer_StableVersion_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockStreamer_StableVersion_OngoingVerification struct {
	mock              *MockStreamer
	methodInvocations []pegomock.MethodInvocation
}

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

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

func (verifier *VerifierMockStreamer) StableVersionNumber(_param0 versionstream.VersionKind, _param1 string) *MockStreamer_StableVersionNumber_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "StableVersionNumber", params, verifier.timeout)
	return &MockStreamer_StableVersionNumber_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockStreamer_StableVersionNumber_OngoingVerification struct {
	mock              *MockStreamer
	methodInvocations []pegomock.MethodInvocation
}

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

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

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

type MockStreamer_VerifyPackage_OngoingVerification struct {
	mock              *MockStreamer
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockStreamer_VerifyPackage_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 *VerifierMockStreamer) VerifyPackages(_param0 map[string]string) *MockStreamer_VerifyPackages_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "VerifyPackages", params, verifier.timeout)
	return &MockStreamer_VerifyPackages_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockStreamer_VerifyPackages_OngoingVerification struct {
	mock              *MockStreamer
	methodInvocations []pegomock.MethodInvocation
}

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

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