mock

type BlockClientMock ¶

type BlockClientMock struct {
	// LatestSyncInfoFunc mocks the LatestSyncInfo method.
	LatestSyncInfoFunc func(ctx context.Context) (*coretypes.SyncInfo, error)

	// SubscribeFunc mocks the Subscribe method.
	SubscribeFunc func(ctx context.Context, subscriber string, query string, outCapacity ...int) (<-chan coretypes.ResultEvent, error)

	// UnsubscribeFunc mocks the Unsubscribe method.
	UnsubscribeFunc func(ctx context.Context, subscriber string, query string) error
	// contains filtered or unexported fields
}

BlockClientMock is a mock implementation of events.BlockClient.

func TestSomethingThatUsesBlockClient(t *testing.T) {

	// make and configure a mocked events.BlockClient
	mockedBlockClient := &BlockClientMock{
		LatestSyncInfoFunc: func(ctx context.Context) (*coretypes.SyncInfo, error) {
			panic("mock out the LatestSyncInfo method")
		},
		SubscribeFunc: func(ctx context.Context, subscriber string, query string, outCapacity ...int) (<-chan coretypes.ResultEvent, error) {
			panic("mock out the Subscribe method")
		},
		UnsubscribeFunc: func(ctx context.Context, subscriber string, query string) error {
			panic("mock out the Unsubscribe method")
		},
	}

	// use mockedBlockClient in code that requires events.BlockClient
	// and then make assertions.

}

func (mock *BlockClientMock) LatestSyncInfo(ctx context.Context) (*coretypes.SyncInfo, error)

func (mock *BlockClientMock) LatestSyncInfoCalls() []struct {
	Ctx context.Context
}

len(mockedBlockClient.LatestSyncInfoCalls())

func (mock *BlockClientMock) Subscribe(ctx context.Context, subscriber string, query string, outCapacity ...int) (<-chan coretypes.ResultEvent, error)

func (mock *BlockClientMock) SubscribeCalls() []struct {
	Ctx         context.Context
	Subscriber  string
	Query       string
	OutCapacity []int
}

len(mockedBlockClient.SubscribeCalls())

func (mock *BlockClientMock) Unsubscribe(ctx context.Context, subscriber string, query string) error

func (mock *BlockClientMock) UnsubscribeCalls() []struct {
	Ctx        context.Context
	Subscriber string
	Query      string
}

len(mockedBlockClient.UnsubscribeCalls())

type BlockNotifierMock ¶

type BlockNotifierMock struct {
	// BlockHeightsFunc mocks the BlockHeights method.
	BlockHeightsFunc func(ctx context.Context) (<-chan int64, <-chan error)

	// DoneFunc mocks the Done method.
	DoneFunc func() <-chan struct{}
	// contains filtered or unexported fields
}

BlockNotifierMock is a mock implementation of events.BlockNotifier.

func TestSomethingThatUsesBlockNotifier(t *testing.T) {

	// make and configure a mocked events.BlockNotifier
	mockedBlockNotifier := &BlockNotifierMock{
		BlockHeightsFunc: func(ctx context.Context) (<-chan int64, <-chan error) {
			panic("mock out the BlockHeights method")
		},
		DoneFunc: func() <-chan struct{} {
			panic("mock out the Done method")
		},
	}

	// use mockedBlockNotifier in code that requires events.BlockNotifier
	// and then make assertions.

}

func (mock *BlockNotifierMock) BlockHeights(ctx context.Context) (<-chan int64, <-chan error)

func (mock *BlockNotifierMock) BlockHeightsCalls() []struct {
	Ctx context.Context
}

len(mockedBlockNotifier.BlockHeightsCalls())

func (mock *BlockNotifierMock) Done() <-chan struct{}

func (mock *BlockNotifierMock) DoneCalls() []struct {
}

len(mockedBlockNotifier.DoneCalls())

type BlockResultClientMock ¶

type BlockResultClientMock struct {
	// BlockResultsFunc mocks the BlockResults method.
	BlockResultsFunc func(ctx context.Context, height *int64) (*coretypes.ResultBlockResults, error)
	// contains filtered or unexported fields
}

BlockResultClientMock is a mock implementation of events.BlockResultClient.

func TestSomethingThatUsesBlockResultClient(t *testing.T) {

	// make and configure a mocked events.BlockResultClient
	mockedBlockResultClient := &BlockResultClientMock{
		BlockResultsFunc: func(ctx context.Context, height *int64) (*coretypes.ResultBlockResults, error) {
			panic("mock out the BlockResults method")
		},
	}

	// use mockedBlockResultClient in code that requires events.BlockResultClient
	// and then make assertions.

}

func (mock *BlockResultClientMock) BlockResults(ctx context.Context, height *int64) (*coretypes.ResultBlockResults, error)

func (mock *BlockResultClientMock) BlockResultsCalls() []struct {
	Ctx    context.Context
	Height *int64
}

len(mockedBlockResultClient.BlockResultsCalls())

type BlockSourceMock ¶

type BlockSourceMock struct {
	// BlockResultsFunc mocks the BlockResults method.
	BlockResultsFunc func(ctx context.Context) (<-chan *coretypes.ResultBlockResults, <-chan error)

	// DoneFunc mocks the Done method.
	DoneFunc func() <-chan struct{}
	// contains filtered or unexported fields
}

BlockSourceMock is a mock implementation of events.BlockSource.

func TestSomethingThatUsesBlockSource(t *testing.T) {

	// make and configure a mocked events.BlockSource
	mockedBlockSource := &BlockSourceMock{
		BlockResultsFunc: func(ctx context.Context) (<-chan *coretypes.ResultBlockResults, <-chan error) {
			panic("mock out the BlockResults method")
		},
		DoneFunc: func() <-chan struct{} {
			panic("mock out the Done method")
		},
	}

	// use mockedBlockSource in code that requires events.BlockSource
	// and then make assertions.

}

func (mock *BlockSourceMock) BlockResults(ctx context.Context) (<-chan *coretypes.ResultBlockResults, <-chan error)

func (mock *BlockSourceMock) BlockResultsCalls() []struct {
	Ctx context.Context
}

len(mockedBlockSource.BlockResultsCalls())

func (mock *BlockSourceMock) Done() <-chan struct{}

func (mock *BlockSourceMock) DoneCalls() []struct {
}

len(mockedBlockSource.DoneCalls())

type Query ¶

type Query tmpubsub.Query

Query interface alias for mocking

type QueryMock ¶

type QueryMock struct {
	// MatchesFunc mocks the Matches method.
	MatchesFunc func(events map[string][]string) (bool, error)

	// StringFunc mocks the String method.
	StringFunc func() string
	// contains filtered or unexported fields
}

QueryMock is a mock implementation of Query.

func TestSomethingThatUsesQuery(t *testing.T) {

	// make and configure a mocked Query
	mockedQuery := &QueryMock{
		MatchesFunc: func(events map[string][]string) (bool, error) {
			panic("mock out the Matches method")
		},
		StringFunc: func() string {
			panic("mock out the String method")
		},
	}

	// use mockedQuery in code that requires Query
	// and then make assertions.

}

func (mock *QueryMock) Matches(events map[string][]string) (bool, error)

func (mock *QueryMock) MatchesCalls() []struct {
	Events map[string][]string
}

len(mockedQuery.MatchesCalls())

func (mock *QueryMock) String() string

func (mock *QueryMock) StringCalls() []struct {
}

len(mockedQuery.StringCalls())