mocks_grpc_test.go

// Code generated by moq; DO NOT EDIT.
// github.com/matryer/moq

package consul

import (
	"google.golang.org/grpc/resolver"
	"google.golang.org/grpc/serviceconfig"
	"sync"
)

// Ensure, that ClientConnMock does implement resolver.ClientConn.
// If this is not the case, regenerate this file with moq.
var _ resolver.ClientConn = &ClientConnMock{}

// ClientConnMock is a mock implementation of resolver.ClientConn.
//
//	func TestSomethingThatUsesClientConn(t *testing.T) {
//
//		// make and configure a mocked resolver.ClientConn
//		mockedClientConn := &ClientConnMock{
//			NewAddressFunc: func(addresses []resolver.Address)  {
//				panic("mock out the NewAddress method")
//			},
//			NewServiceConfigFunc: func(serviceConfig string)  {
//				panic("mock out the NewServiceConfig method")
//			},
//			ParseServiceConfigFunc: func(serviceConfigJSON string) *serviceconfig.ParseResult {
//				panic("mock out the ParseServiceConfig method")
//			},
//			ReportErrorFunc: func(err error)  {
//				panic("mock out the ReportError method")
//			},
//			UpdateStateFunc: func(state resolver.State) error {
//				panic("mock out the UpdateState method")
//			},
//		}
//
//		// use mockedClientConn in code that requires resolver.ClientConn
//		// and then make assertions.
//
//	}
type ClientConnMock struct {
	// NewAddressFunc mocks the NewAddress method.
	NewAddressFunc func(addresses []resolver.Address)

	// NewServiceConfigFunc mocks the NewServiceConfig method.
	NewServiceConfigFunc func(serviceConfig string)

	// ParseServiceConfigFunc mocks the ParseServiceConfig method.
	ParseServiceConfigFunc func(serviceConfigJSON string) *serviceconfig.ParseResult

	// ReportErrorFunc mocks the ReportError method.
	ReportErrorFunc func(err error)

	// UpdateStateFunc mocks the UpdateState method.
	UpdateStateFunc func(state resolver.State) error

	// calls tracks calls to the methods.
	calls struct {
		// NewAddress holds details about calls to the NewAddress method.
		NewAddress []struct {
			// Addresses is the addresses argument value.
			Addresses []resolver.Address
		}
		// NewServiceConfig holds details about calls to the NewServiceConfig method.
		NewServiceConfig []struct {
			// ServiceConfig is the serviceConfig argument value.
			ServiceConfig string
		}
		// ParseServiceConfig holds details about calls to the ParseServiceConfig method.
		ParseServiceConfig []struct {
			// ServiceConfigJSON is the serviceConfigJSON argument value.
			ServiceConfigJSON string
		}
		// ReportError holds details about calls to the ReportError method.
		ReportError []struct {
			// Err is the err argument value.
			Err error
		}
		// UpdateState holds details about calls to the UpdateState method.
		UpdateState []struct {
			// State is the state argument value.
			State resolver.State
		}
	}
	lockNewAddress         sync.RWMutex
	lockNewServiceConfig   sync.RWMutex
	lockParseServiceConfig sync.RWMutex
	lockReportError        sync.RWMutex
	lockUpdateState        sync.RWMutex
}

// NewAddress calls NewAddressFunc.
func (mock *ClientConnMock) NewAddress(addresses []resolver.Address) {
	if mock.NewAddressFunc == nil {
		panic("ClientConnMock.NewAddressFunc: method is nil but ClientConn.NewAddress was just called")
	}
	callInfo := struct {
		Addresses []resolver.Address
	}{
		Addresses: addresses,
	}
	mock.lockNewAddress.Lock()
	mock.calls.NewAddress = append(mock.calls.NewAddress, callInfo)
	mock.lockNewAddress.Unlock()
	mock.NewAddressFunc(addresses)
}

// NewAddressCalls gets all the calls that were made to NewAddress.
// Check the length with:
//
//	len(mockedClientConn.NewAddressCalls())
func (mock *ClientConnMock) NewAddressCalls() []struct {
	Addresses []resolver.Address
} {
	var calls []struct {
		Addresses []resolver.Address
	}
	mock.lockNewAddress.RLock()
	calls = mock.calls.NewAddress
	mock.lockNewAddress.RUnlock()
	return calls
}

// NewServiceConfig calls NewServiceConfigFunc.
func (mock *ClientConnMock) NewServiceConfig(serviceConfig string) {
	if mock.NewServiceConfigFunc == nil {
		panic("ClientConnMock.NewServiceConfigFunc: method is nil but ClientConn.NewServiceConfig was just called")
	}
	callInfo := struct {
		ServiceConfig string
	}{
		ServiceConfig: serviceConfig,
	}
	mock.lockNewServiceConfig.Lock()
	mock.calls.NewServiceConfig = append(mock.calls.NewServiceConfig, callInfo)
	mock.lockNewServiceConfig.Unlock()
	mock.NewServiceConfigFunc(serviceConfig)
}

// NewServiceConfigCalls gets all the calls that were made to NewServiceConfig.
// Check the length with:
//
//	len(mockedClientConn.NewServiceConfigCalls())
func (mock *ClientConnMock) NewServiceConfigCalls() []struct {
	ServiceConfig string
} {
	var calls []struct {
		ServiceConfig string
	}
	mock.lockNewServiceConfig.RLock()
	calls = mock.calls.NewServiceConfig
	mock.lockNewServiceConfig.RUnlock()
	return calls
}

// ParseServiceConfig calls ParseServiceConfigFunc.
func (mock *ClientConnMock) ParseServiceConfig(serviceConfigJSON string) *serviceconfig.ParseResult {
	if mock.ParseServiceConfigFunc == nil {
		panic("ClientConnMock.ParseServiceConfigFunc: method is nil but ClientConn.ParseServiceConfig was just called")
	}
	callInfo := struct {
		ServiceConfigJSON string
	}{
		ServiceConfigJSON: serviceConfigJSON,
	}
	mock.lockParseServiceConfig.Lock()
	mock.calls.ParseServiceConfig = append(mock.calls.ParseServiceConfig, callInfo)
	mock.lockParseServiceConfig.Unlock()
	return mock.ParseServiceConfigFunc(serviceConfigJSON)
}

// ParseServiceConfigCalls gets all the calls that were made to ParseServiceConfig.
// Check the length with:
//
//	len(mockedClientConn.ParseServiceConfigCalls())
func (mock *ClientConnMock) ParseServiceConfigCalls() []struct {
	ServiceConfigJSON string
} {
	var calls []struct {
		ServiceConfigJSON string
	}
	mock.lockParseServiceConfig.RLock()
	calls = mock.calls.ParseServiceConfig
	mock.lockParseServiceConfig.RUnlock()
	return calls
}

// ReportError calls ReportErrorFunc.
func (mock *ClientConnMock) ReportError(err error) {
	if mock.ReportErrorFunc == nil {
		panic("ClientConnMock.ReportErrorFunc: method is nil but ClientConn.ReportError was just called")
	}
	callInfo := struct {
		Err error
	}{
		Err: err,
	}
	mock.lockReportError.Lock()
	mock.calls.ReportError = append(mock.calls.ReportError, callInfo)
	mock.lockReportError.Unlock()
	mock.ReportErrorFunc(err)
}

// ReportErrorCalls gets all the calls that were made to ReportError.
// Check the length with:
//
//	len(mockedClientConn.ReportErrorCalls())
func (mock *ClientConnMock) ReportErrorCalls() []struct {
	Err error
} {
	var calls []struct {
		Err error
	}
	mock.lockReportError.RLock()
	calls = mock.calls.ReportError
	mock.lockReportError.RUnlock()
	return calls
}

// UpdateState calls UpdateStateFunc.
func (mock *ClientConnMock) UpdateState(state resolver.State) error {
	if mock.UpdateStateFunc == nil {
		panic("ClientConnMock.UpdateStateFunc: method is nil but ClientConn.UpdateState was just called")
	}
	callInfo := struct {
		State resolver.State
	}{
		State: state,
	}
	mock.lockUpdateState.Lock()
	mock.calls.UpdateState = append(mock.calls.UpdateState, callInfo)
	mock.lockUpdateState.Unlock()
	return mock.UpdateStateFunc(state)
}

// UpdateStateCalls gets all the calls that were made to UpdateState.
// Check the length with:
//
//	len(mockedClientConn.UpdateStateCalls())
func (mock *ClientConnMock) UpdateStateCalls() []struct {
	State resolver.State
} {
	var calls []struct {
		State resolver.State
	}
	mock.lockUpdateState.RLock()
	calls = mock.calls.UpdateState
	mock.lockUpdateState.RUnlock()
	return calls
}