testhelpers

package
v1.9.7-0...-38a7985 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: 22 Imported by: 0

Documentation

Overview

Package testhelpers is a generated GoMock package.

Package testhelpers is a generated GoMock package.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func MakeSlotIdentityPreimage 

func MakeSlotIdentityPreimage(t *testing.T, slot uint64) *shutter.IdentityPreimage

func MockDecryptionKeysEnvelopeData 

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

func MockDecryptionKeysMsg 

func MockDecryptionKeysMsg(topic string, envelopeData []byte) *pubsub.Message

func MockEonTrackerCreator 

func MockEonTrackerCreator(opts ...MockEonTrackerCreatorOpt) func(t *testing.T) *MockEonTracker

func MockIdentityPreimages 

func MockIdentityPreimages(t *testing.T, count uint64) shutter.IdentityPreimages

func MockIdentityPreimagesWithSlotIp 

func MockIdentityPreimagesWithSlotIp(t *testing.T, slot uint64, count uint64) shutter.IdentityPreimages

func MockSlotCalculatorCreator 

func MockSlotCalculatorCreator(opts ...MockSlotCalculatorCreatorOpt) func(t *testing.T) *MockSlotCalculator

func Signatures 

func Signatures(t *testing.T, signers []Keyper, data shutter.DecryptionKeysSignatureData) [][]byte

func Uint64ToIdentityPreimage 

func Uint64ToIdentityPreimage(t *testing.T, i uint64) *shutter.IdentityPreimage

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 CurrentEonMockResult 

type CurrentEonMockResult struct {
	Eon shutter.Eon
	Ok  bool
}

type EonKeyGeneration 

type EonKeyGeneration struct {
	EonIndex        shutter.EonIndex
	ActivationBlock uint64
	Threshold       uint64
	Keypers         []Keyper
	MaliciousKeyper Keyper
	EonPublicKey    *shuttercrypto.EonPublicKey
}

func MockEonKeyGeneration 

func MockEonKeyGeneration(t *testing.T, idx shutter.EonIndex, threshold, numKeypers uint64) EonKeyGeneration

func (EonKeyGeneration) DecryptionKeys 

func (ekg EonKeyGeneration) DecryptionKeys(t *testing.T, signers []Keyper, ips shutter.IdentityPreimages) []*proto.Key

func (EonKeyGeneration) Eon 

func (ekg EonKeyGeneration) Eon() shutter.Eon

func (EonKeyGeneration) EpochSecretKey 

func (ekg EonKeyGeneration) EpochSecretKey(t *testing.T, signers []Keyper, ip *shutter.IdentityPreimage) *shuttercrypto.EpochSecretKey

type EonTracker 

type EonTracker interface {
	shutter.EonTracker
}

type Keyper 

type Keyper struct {
	Index             int
	PrivateKey        *ecdsa.PrivateKey
	EonSecretKeyShare *shuttercrypto.EonSecretKeyShare
	EonPublicKeyShare *shuttercrypto.EonPublicKeyShare
}

func (Keyper) Address 

func (k Keyper) Address() libcommon.Address

func (Keyper) EpochSecretKeyShare 

func (k Keyper) EpochSecretKeyShare(ip *shutter.IdentityPreimage) *shuttercrypto.EpochSecretKeyShare

func (Keyper) PublicKey 

func (k Keyper) PublicKey() ecdsa.PublicKey

type MockDecryptionKeysEnvelopeDataOptions 

type MockDecryptionKeysEnvelopeDataOptions struct {
	EonIndex      shutter.EonIndex
	Keys          []*shutterproto.Key
	NilExtra      bool
	Slot          uint64
	TxnPointer    uint64
	SignerIndices []uint64
	Signatures    [][]byte
	InstanceId    uint64
	Version       string
}

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) EonByBlockNum 

func (m *MockEonTracker) EonByBlockNum(blockNum uint64) (shutter.Eon, bool)

EonByBlockNum mocks base method.

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 MockEonTrackerCreatorOpt 

type MockEonTrackerCreatorOpt func(mock *MockEonTracker)

func WithCurrentEonMockResult 

func WithCurrentEonMockResult(results ...CurrentEonMockResult) MockEonTrackerCreatorOpt

func WithRecentEonMockResult 

func WithRecentEonMockResult(results ...RecentEonMockResult) MockEonTrackerCreatorOpt

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 MockEonTrackerEonByBlockNumCall 

type MockEonTrackerEonByBlockNumCall struct {
	*gomock.Call
}

MockEonTrackerEonByBlockNumCall wrap *gomock.Call

func (*MockEonTrackerEonByBlockNumCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockEonTrackerEonByBlockNumCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockEonTrackerEonByBlockNumCall) Return 

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

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) EonByBlockNum 

func (mr *MockEonTrackerMockRecorder) EonByBlockNum(blockNum any) *MockEonTrackerEonByBlockNumCall

EonByBlockNum indicates an expected call of EonByBlockNum.

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.

func (*MockSlotCalculator) SecondsPerSlot 

func (m *MockSlotCalculator) SecondsPerSlot() uint64

SecondsPerSlot mocks base method.

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 MockSlotCalculatorCreatorOpt 

type MockSlotCalculatorCreatorOpt func(mock *MockSlotCalculator)

func WithCalcCurrentSlotMockResult 

func WithCalcCurrentSlotMockResult(results ...uint64) MockSlotCalculatorCreatorOpt

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.

func (*MockSlotCalculatorMockRecorder) SecondsPerSlot 

func (mr *MockSlotCalculatorMockRecorder) SecondsPerSlot() *MockSlotCalculatorSecondsPerSlotCall

SecondsPerSlot indicates an expected call of SecondsPerSlot.

type MockSlotCalculatorSecondsPerSlotCall 

type MockSlotCalculatorSecondsPerSlotCall struct {
	*gomock.Call
}

MockSlotCalculatorSecondsPerSlotCall wrap *gomock.Call

func (*MockSlotCalculatorSecondsPerSlotCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockSlotCalculatorSecondsPerSlotCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockSlotCalculatorSecondsPerSlotCall) Return 

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

Return rewrite *gomock.Call.Return

type RecentEonMockResult 

type RecentEonMockResult struct {
	Eon shutter.Eon
	Ok  bool
}

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.