testhelpers

package
v1.9.7-0...-42bb602 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 25, 2025 License: LGPL-3.0 Imports: 14 Imported by: 0

Documentation

Overview

Package testhelpers is a generated GoMock package.

Package testhelpers is a generated GoMock package.

Index

Constants

View Source 
const (
	TestInstanceId           = 123
	TestMaxNumKeysPerMessage = 3
)

Variables

This section is empty.

Functions

func MockDecryptionKeysEnvelopeData 

func MockDecryptionKeysEnvelopeData(t *testing.T, opts MockDecryptionKeysMsgOptions) []byte

func MockDecryptionKeysMsg 

func MockDecryptionKeysMsg(t *testing.T, opts MockDecryptionKeysMsgOptions) *pubsub.Message

Types

type CollectingLogHandler 

type CollectingLogHandler struct {
	// contains filtered or unexported fields
}

func NewCollectingLogHandler 

func NewCollectingLogHandler(handler log.Handler) *CollectingLogHandler

func (*CollectingLogHandler) Contains 

func (clh *CollectingLogHandler) Contains(subStr string) bool

func (*CollectingLogHandler) ContainsAll 

func (clh *CollectingLogHandler) ContainsAll(subStrs []string) bool

func (*CollectingLogHandler) FormattedRecords 

func (clh *CollectingLogHandler) FormattedRecords() []string

func (*CollectingLogHandler) Log 

func (clh *CollectingLogHandler) Log(r *log.Record) error

type EonTracker 

type EonTracker interface {
	shutter.EonTracker
}

type MockDecryptionKeysMsgOptions 

type MockDecryptionKeysMsgOptions struct {
	Eon                  uint64
	Keys                 [][]byte
	IdentityPreimages    [][]byte
	NilExtra             bool
	Slot                 uint64
	TxPointer            uint64
	SignerIndices        []uint64
	Signatures           [][]byte
	InstanceIdOverride   uint64
	VersionOverride      string
	TopicOverride        string
	EnvelopeDataOverride []byte
}

type MockEonTracker 

type MockEonTracker struct {
	// contains filtered or unexported fields
}

MockEonTracker is a mock of EonTracker interface.

func NewMockEonTracker 

func NewMockEonTracker(ctrl *gomock.Controller) *MockEonTracker

NewMockEonTracker creates a new mock instance.

func (*MockEonTracker) CurrentEon 

func (m *MockEonTracker) CurrentEon() (shutter.Eon, bool)

CurrentEon mocks base method.

func (*MockEonTracker) EXPECT 

func (m *MockEonTracker) EXPECT() *MockEonTrackerMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockEonTracker) RecentEon 

func (m *MockEonTracker) RecentEon(index shutter.EonIndex) (shutter.Eon, bool)

RecentEon mocks base method.

func (*MockEonTracker) Run 

func (m *MockEonTracker) Run(ctx context.Context) error

Run mocks base method.

type MockEonTrackerCurrentEonCall 

type MockEonTrackerCurrentEonCall struct {
	*gomock.Call
}

MockEonTrackerCurrentEonCall wrap *gomock.Call

func (*MockEonTrackerCurrentEonCall) Do 

func (c *MockEonTrackerCurrentEonCall) Do(f func() (shutter.Eon, bool)) *MockEonTrackerCurrentEonCall

Do rewrite *gomock.Call.Do

func (*MockEonTrackerCurrentEonCall) DoAndReturn 

func (c *MockEonTrackerCurrentEonCall) DoAndReturn(f func() (shutter.Eon, bool)) *MockEonTrackerCurrentEonCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockEonTrackerCurrentEonCall) Return 

func (c *MockEonTrackerCurrentEonCall) Return(arg0 shutter.Eon, arg1 bool) *MockEonTrackerCurrentEonCall

Return rewrite *gomock.Call.Return

type MockEonTrackerMockRecorder 

type MockEonTrackerMockRecorder struct {
	// contains filtered or unexported fields
}

MockEonTrackerMockRecorder is the mock recorder for MockEonTracker.

func (*MockEonTrackerMockRecorder) CurrentEon 

func (mr *MockEonTrackerMockRecorder) CurrentEon() *MockEonTrackerCurrentEonCall

CurrentEon indicates an expected call of CurrentEon.

func (*MockEonTrackerMockRecorder) RecentEon 

func (mr *MockEonTrackerMockRecorder) RecentEon(index any) *MockEonTrackerRecentEonCall

RecentEon indicates an expected call of RecentEon.

func (*MockEonTrackerMockRecorder) Run 

func (mr *MockEonTrackerMockRecorder) Run(ctx any) *MockEonTrackerRunCall

Run indicates an expected call of Run.

type MockEonTrackerRecentEonCall 

type MockEonTrackerRecentEonCall struct {
	*gomock.Call
}

MockEonTrackerRecentEonCall wrap *gomock.Call

func (*MockEonTrackerRecentEonCall) Do 

func (c *MockEonTrackerRecentEonCall) Do(f func(shutter.EonIndex) (shutter.Eon, bool)) *MockEonTrackerRecentEonCall

Do rewrite *gomock.Call.Do

func (*MockEonTrackerRecentEonCall) DoAndReturn 

func (c *MockEonTrackerRecentEonCall) DoAndReturn(f func(shutter.EonIndex) (shutter.Eon, bool)) *MockEonTrackerRecentEonCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockEonTrackerRecentEonCall) Return 

func (c *MockEonTrackerRecentEonCall) Return(arg0 shutter.Eon, arg1 bool) *MockEonTrackerRecentEonCall

Return rewrite *gomock.Call.Return

type MockEonTrackerRunCall 

type MockEonTrackerRunCall struct {
	*gomock.Call
}

MockEonTrackerRunCall wrap *gomock.Call

func (*MockEonTrackerRunCall) Do 

func (c *MockEonTrackerRunCall) Do(f func(context.Context) error) *MockEonTrackerRunCall

Do rewrite *gomock.Call.Do

func (*MockEonTrackerRunCall) DoAndReturn 

func (c *MockEonTrackerRunCall) DoAndReturn(f func(context.Context) error) *MockEonTrackerRunCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockEonTrackerRunCall) Return 

func (c *MockEonTrackerRunCall) Return(arg0 error) *MockEonTrackerRunCall

Return rewrite *gomock.Call.Return

type MockSlotCalculator 

type MockSlotCalculator struct {
	// contains filtered or unexported fields
}

MockSlotCalculator is a mock of SlotCalculator interface.

func NewMockSlotCalculator 

func NewMockSlotCalculator(ctrl *gomock.Controller) *MockSlotCalculator

NewMockSlotCalculator creates a new mock instance.

func (*MockSlotCalculator) CalcCurrentSlot 

func (m *MockSlotCalculator) CalcCurrentSlot() uint64

CalcCurrentSlot mocks base method.

func (*MockSlotCalculator) CalcSlot 

func (m *MockSlotCalculator) CalcSlot(timestamp uint64) (uint64, error)

CalcSlot mocks base method.

func (*MockSlotCalculator) CalcSlotAge 

func (m *MockSlotCalculator) CalcSlotAge(slot uint64) time.Duration

CalcSlotAge mocks base method.

func (*MockSlotCalculator) EXPECT 

func (m *MockSlotCalculator) EXPECT() *MockSlotCalculatorMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

type MockSlotCalculatorCalcCurrentSlotCall 

type MockSlotCalculatorCalcCurrentSlotCall struct {
	*gomock.Call
}

MockSlotCalculatorCalcCurrentSlotCall wrap *gomock.Call

func (*MockSlotCalculatorCalcCurrentSlotCall) Do 

func (c *MockSlotCalculatorCalcCurrentSlotCall) Do(f func() uint64) *MockSlotCalculatorCalcCurrentSlotCall

Do rewrite *gomock.Call.Do

func (*MockSlotCalculatorCalcCurrentSlotCall) DoAndReturn 

func (c *MockSlotCalculatorCalcCurrentSlotCall) DoAndReturn(f func() uint64) *MockSlotCalculatorCalcCurrentSlotCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockSlotCalculatorCalcCurrentSlotCall) Return 

func (c *MockSlotCalculatorCalcCurrentSlotCall) Return(arg0 uint64) *MockSlotCalculatorCalcCurrentSlotCall

Return rewrite *gomock.Call.Return

type MockSlotCalculatorCalcSlotAgeCall 

type MockSlotCalculatorCalcSlotAgeCall struct {
	*gomock.Call
}

MockSlotCalculatorCalcSlotAgeCall wrap *gomock.Call

func (*MockSlotCalculatorCalcSlotAgeCall) Do 

func (c *MockSlotCalculatorCalcSlotAgeCall) Do(f func(uint64) time.Duration) *MockSlotCalculatorCalcSlotAgeCall

Do rewrite *gomock.Call.Do

func (*MockSlotCalculatorCalcSlotAgeCall) DoAndReturn 

func (c *MockSlotCalculatorCalcSlotAgeCall) DoAndReturn(f func(uint64) time.Duration) *MockSlotCalculatorCalcSlotAgeCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockSlotCalculatorCalcSlotAgeCall) Return 

func (c *MockSlotCalculatorCalcSlotAgeCall) Return(arg0 time.Duration) *MockSlotCalculatorCalcSlotAgeCall

Return rewrite *gomock.Call.Return

type MockSlotCalculatorCalcSlotCall 

type MockSlotCalculatorCalcSlotCall struct {
	*gomock.Call
}

MockSlotCalculatorCalcSlotCall wrap *gomock.Call

func (*MockSlotCalculatorCalcSlotCall) Do 

func (c *MockSlotCalculatorCalcSlotCall) Do(f func(uint64) (uint64, error)) *MockSlotCalculatorCalcSlotCall

Do rewrite *gomock.Call.Do

func (*MockSlotCalculatorCalcSlotCall) DoAndReturn 

func (c *MockSlotCalculatorCalcSlotCall) DoAndReturn(f func(uint64) (uint64, error)) *MockSlotCalculatorCalcSlotCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockSlotCalculatorCalcSlotCall) Return 

func (c *MockSlotCalculatorCalcSlotCall) Return(arg0 uint64, arg1 error) *MockSlotCalculatorCalcSlotCall

Return rewrite *gomock.Call.Return

type MockSlotCalculatorMockRecorder 

type MockSlotCalculatorMockRecorder struct {
	// contains filtered or unexported fields
}

MockSlotCalculatorMockRecorder is the mock recorder for MockSlotCalculator.

func (*MockSlotCalculatorMockRecorder) CalcCurrentSlot 

func (mr *MockSlotCalculatorMockRecorder) CalcCurrentSlot() *MockSlotCalculatorCalcCurrentSlotCall

CalcCurrentSlot indicates an expected call of CalcCurrentSlot.

func (*MockSlotCalculatorMockRecorder) CalcSlot 

func (mr *MockSlotCalculatorMockRecorder) CalcSlot(timestamp any) *MockSlotCalculatorCalcSlotCall

CalcSlot indicates an expected call of CalcSlot.

func (*MockSlotCalculatorMockRecorder) CalcSlotAge 

func (mr *MockSlotCalculatorMockRecorder) CalcSlotAge(slot any) *MockSlotCalculatorCalcSlotAgeCall

CalcSlotAge indicates an expected call of CalcSlotAge.

type SlotCalculator 

type SlotCalculator interface {
	shutter.SlotCalculator
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.