mocks

Documentation

Index

• func ConvertStorageOutput[K comparable, V any, R any](fn func(key K) (V, error), mapper func(V) R) func(key K) (R, error)
• func NewFinalizedHeaderCache(t *testing.T, state protocol.State) *finalizedHeaderCache
• func StorageMapGetter[K comparable, V any](m map[K]V) func(key K) (V, error)
• type EpochQuery
  • func NewEpochQuery(t *testing.T, counter uint64, epochs ...protocol.Epoch) *EpochQuery
  • func (mock *EpochQuery) Add(epoch protocol.Epoch)
  • func (mock *EpochQuery) ByCounter(counter uint64) protocol.Epoch
  • func (mock *EpochQuery) Current() protocol.Epoch
  • func (mock *EpochQuery) Next() protocol.Epoch
  • func (mock *EpochQuery) Phase() flow.EpochPhase
  • func (mock *EpochQuery) Previous() protocol.Epoch
  • func (mock *EpochQuery) Transition()
• type Params
  • func (p *Params) ChainID() flow.ChainID
  • func (p *Params) EpochFallbackTriggered() (bool, error)
  • func (p *Params) FinalizedRoot() *flow.Header
  • func (p *Params) ProtocolVersion() uint
  • func (p *Params) Seal() *flow.Seal
  • func (p *Params) SealedRoot() *flow.Header
  • func (p *Params) SporkID() flow.Identifier
  • func (p *Params) SporkRootBlockHeight() uint64
• type ProtocolState
  • func NewProtocolState() *ProtocolState
  • func (ps *ProtocolState) AtBlockID(blockID flow.Identifier) protocol.Snapshot
  • func (ps *ProtocolState) AtHeight(height uint64) protocol.Snapshot
  • func (m *ProtocolState) Bootstrap(root *flow.Block, result *flow.ExecutionResult, seal *flow.Seal) error
  • func (m *ProtocolState) Extend(block *flow.Block) error
  • func (ps *ProtocolState) Final() protocol.Snapshot
  • func (m *ProtocolState) Finalize(blockID flow.Identifier) error
  • func (ps *ProtocolState) Params() protocol.Params

Functions

func ConvertStorageOutput

func ConvertStorageOutput[K comparable, V any, R any](fn func(key K) (V, error), mapper func(V) R) func(key K) (R, error)

ConvertStorageOutput maps the output type from a getter function to a different type. This is useful to avoid maintaining multiple maps for the same data.

Example usage:

blockMap := map[uint64]*flow.Block{}

headers.On("BlockIDByHeight", mock.AnythingOfType("uint64")).Return(
	mocks.ConvertStorageOutput(
		mocks.StorageMapGetter(s.blockMap),
		func(block *flow.Block) flow.Identifier { return block.ID() },
	),
)

func NewFinalizedHeaderCache

func NewFinalizedHeaderCache(t *testing.T, state protocol.State) *finalizedHeaderCache

func StorageMapGetter

func StorageMapGetter[K comparable, V any](m map[K]V) func(key K) (V, error)

StorageMapGetter implements a simple generic getter function for mock storage methods. This is useful to avoid duplicating boilerplate code for mock storage methods.

Example: Instead of the following code:

results.On("ByID", mock.AnythingOfType("flow.Identifier")).Return(
	func(resultID flow.Identifier) (*flow.ExecutionResult, error) {
		if result, ok := s.resultMap[resultID]; ok {
			return result, nil
		}
		return nil, storage.ErrNotFound
	},
)

Use this:

results.On("ByID", mock.AnythingOfType("flow.Identifier")).Return(
	mocks.StorageMapGetter(s.resultMap),
)

Types

type EpochQuery

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

EpochQuery implements protocol.EpochQuery for testing purposes. Safe for concurrent use by multiple goroutines.

func NewEpochQuery

func NewEpochQuery(t *testing.T, counter uint64, epochs ...protocol.Epoch) *EpochQuery

func (*EpochQuery) Add

func (mock *EpochQuery) Add(epoch protocol.Epoch)

func (*EpochQuery) ByCounter

func (mock *EpochQuery) ByCounter(counter uint64) protocol.Epoch

func (*EpochQuery) Current

func (mock *EpochQuery) Current() protocol.Epoch

func (*EpochQuery) Next

func (mock *EpochQuery) Next() protocol.Epoch

func (*EpochQuery) Phase

func (mock *EpochQuery) Phase() flow.EpochPhase

Phase returns a phase consistent with the current epoch state.

func (*EpochQuery) Previous

func (mock *EpochQuery) Previous() protocol.Epoch

func (*EpochQuery) Transition

func (mock *EpochQuery) Transition()

type Params

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

func (*Params) ChainID

func (p *Params) ChainID() flow.ChainID

func (*Params) EpochFallbackTriggered

func (p *Params) EpochFallbackTriggered() (bool, error)

func (*Params) FinalizedRoot

func (p *Params) FinalizedRoot() *flow.Header

func (*Params) ProtocolVersion

func (p *Params) ProtocolVersion() uint

func (*Params) Seal

func (p *Params) Seal() *flow.Seal

func (*Params) SealedRoot

func (p *Params) SealedRoot() *flow.Header

func (*Params) SporkID

func (p *Params) SporkID() flow.Identifier

func (*Params) SporkRootBlockHeight

func (p *Params) SporkRootBlockHeight() uint64

type ProtocolState

type ProtocolState struct {
	sync.Mutex
	protocol.ParticipantState
	// contains filtered or unexported fields
}

ProtocolState is a mocked version of protocol state, which has very close behavior to the real implementation but for testing purpose. If you are testing a module that depends on protocol state's behavior, but you don't want to mock up the methods and its return value, then just use this module

func NewProtocolState

func NewProtocolState() *ProtocolState

func (*ProtocolState) AtBlockID

func (ps *ProtocolState) AtBlockID(blockID flow.Identifier) protocol.Snapshot

func (*ProtocolState) AtHeight

func (ps *ProtocolState) AtHeight(height uint64) protocol.Snapshot

func (*ProtocolState) Bootstrap

func (m *ProtocolState) Bootstrap(root *flow.Block, result *flow.ExecutionResult, seal *flow.Seal) error

func (*ProtocolState) Extend

func (m *ProtocolState) Extend(block *flow.Block) error

func (*ProtocolState) Final

func (ps *ProtocolState) Final() protocol.Snapshot

func (*ProtocolState) Finalize

func (m *ProtocolState) Finalize(blockID flow.Identifier) error

func (*ProtocolState) Params

func (ps *ProtocolState) Params() protocol.Params