kit

package
v1.20.0-hyperspace-txi... Latest Latest
Warning

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

 Go to latest Published: Jan 19, 2023 License: Apache-2.0, MIT Imports: 117 Imported by: 4

Documentation

Index

Constants

View Source 
const (
	TestDealStateFailed     = TestDealState(-1)
	TestDealStateInProgress = TestDealState(0)
	TestDealStateComplete   = TestDealState(1)
)
View Source 
const DefaultPresealsPerBootstrapMiner = 2

DefaultPresealsPerBootstrapMiner is the number of preseals that every bootstrap miner has by default. It can be overridden through the PresealSectors option.

View Source 
const EnvRunExpensiveTests = "LOTUS_RUN_EXPENSIVE_TESTS"

EnvRunExpensiveTests is the environment variable that needs to be present and set to value "1" to enable running expensive tests outside of CI.

View Source 
const TestSpt = abi.RegisteredSealProof_StackedDrg2KiBV1_1

Variables

View Source 
var DefaultEnsembleOpts = ensembleOpts{
	// contains filtered or unexported fields
}
View Source 
var DefaultNodeOpts = nodeOpts{
	// contains filtered or unexported fields
}

DefaultNodeOpts are the default options that will be applied to test nodes.

View Source 
var WithSealWorkerTasks = WithTaskTypes(append([]sealtasks.TaskType{sealtasks.TTAddPiece, sealtasks.TTDataCid, sealtasks.TTPreCommit1, sealtasks.TTPreCommit2, sealtasks.TTCommit2, sealtasks.TTUnseal}, DefaultNodeOpts.workerTasks...))

Functions

func AssertFilesEqual 

func AssertFilesEqual(t *testing.T, left, right string)

AssertFilesEqual compares two files by blake2b hash equality and fails the test if unequal.

func CircuitBreaker added in v1.14.0 

func CircuitBreaker(t *testing.T, label string, throttle, timeout time.Duration, cb func() bool)

CircuitBreaker implements a simple time-based circuit breaker used for waiting for async operations to finish.

This is how it works:

  • It runs the `cb` function until it returns true,
  • waiting for `throttle` duration between each iteration,
  • or at most `timeout` duration until it breaks test execution.

You can use it if t.Deadline() is not "granular" enough, and you want to know which specific piece of code timed out, or you need to set different deadlines in the same test.

func CreateImportFile 

func CreateImportFile(ctx context.Context, client api.FullNode, rseed int, size int) (res *api.ImportRes, path string, data []byte, err error)

func CreateRandomCARv1 added in v1.11.2 

func CreateRandomCARv1(t *testing.T, rseed, size int, opts ...GeneratedDAGOpts) (carV1FilePath string, origFilePath string)

CreateRandomFile creates a normal file with the provided seed and the provided size and then transforms it to a CARv1 file and returns it.

func CreateRandomFile 

func CreateRandomFile(t *testing.T, rseed, size int) (path string)

CreateRandomFile creates a random file with the provided seed and the provided size.

func EnsembleMinimal 

func EnsembleMinimal(t *testing.T, opts ...interface{}) (*TestFullNode, *TestMiner, *Ensemble)

EnsembleMinimal creates and starts an Ensemble with a single full node and a single miner. It does not interconnect nodes nor does it begin mining.

This function supports passing both ensemble and node functional options. Functional options are applied to all nodes.

func EnsembleOneTwo 

func EnsembleOneTwo(t *testing.T, opts ...interface{}) (*TestFullNode, *TestMiner, *TestMiner, *Ensemble)

EnsembleOneTwo creates and starts an Ensemble with one full node and two miners. It does not interconnect nodes nor does it begin mining.

This function supports passing both ensemble and node functional options. Functional options are applied to all nodes.

func EnsembleTwoOne 

func EnsembleTwoOne(t *testing.T, opts ...interface{}) (*TestFullNode, *TestFullNode, *TestMiner, *Ensemble)

EnsembleTwoOne creates and starts an Ensemble with two full nodes and one miner. It does not interconnect nodes nor does it begin mining.

This function supports passing both ensemble and node functional options. Functional options are applied to all nodes.

func EnsembleWithMinerAndMarketNodes added in v1.11.1 

func EnsembleWithMinerAndMarketNodes(t *testing.T, opts ...interface{}) (*TestFullNode, *TestMiner, *TestMiner, *Ensemble)

func EnsembleWorker added in v1.15.2 

func EnsembleWorker(t *testing.T, opts ...interface{}) (*TestFullNode, *TestMiner, *TestWorker, *Ensemble)

func Expensive 

func Expensive(t *testing.T)

Expensive marks a test as expensive, skipping it immediately if not running an

func QuietMiningLogs 

func QuietMiningLogs()

func RunClientTest 

func RunClientTest(t *testing.T, cmds []*lcli.Command, clientNode *TestFullNode)

RunClientTest exercises some of the Client CLI commands

func SendFunds 

func SendFunds(ctx context.Context, t *testing.T, sender *TestFullNode, recipient address.Address, amount abi.TokenAmount)

SendFunds sends funds from the default wallet of the specified sender node to the recipient address.

Types

type BlockMiner 

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

BlockMiner is a utility that makes a test miner Mine blocks on a timer.

func NewBlockMiner 

func NewBlockMiner(t *testing.T, miner *TestMiner) *BlockMiner

func (*BlockMiner) InjectNulls 

func (bm *BlockMiner) InjectNulls(rounds abi.ChainEpoch)

InjectNulls injects the specified amount of null rounds in the next mining rounds.

func (*BlockMiner) MineBlocks 

func (bm *BlockMiner) MineBlocks(ctx context.Context, blocktime time.Duration)

func (*BlockMiner) MineBlocksMustPost added in v1.14.0 

func (bm *BlockMiner) MineBlocksMustPost(ctx context.Context, blocktime time.Duration)

Like MineBlocks but refuses to mine until the window post scheduler has wdpost messages in the mempool and everything shuts down if a post fails. It also enforces that every block mined succeeds

func (*BlockMiner) MineUntilBlock 

func (bm *BlockMiner) MineUntilBlock(ctx context.Context, fn *TestFullNode, cb func(abi.ChainEpoch))

func (*BlockMiner) Pause added in v1.17.1 

func (bm *BlockMiner) Pause()

Pause compels the miner to wait for a signal to restart

func (*BlockMiner) Restart added in v1.17.1 

func (bm *BlockMiner) Restart()

Restart continues mining after a pause. This will hang if called before pause

func (*BlockMiner) Stop 

func (bm *BlockMiner) Stop()

Stop stops the block miner.

type CfgOption added in v1.17.1 

type CfgOption func(cfg *config.FullNode) error

type ChainPredicate 

type ChainPredicate func(set *types.TipSet) bool

ChainPredicate encapsulates a chain condition.

func BlockMinedBy 

func BlockMinedBy(miner address.Address) ChainPredicate

BlockMinedBy returns a ChainPredicate that is satisfied when we observe the first block mined by the specified miner.

func HeightAtLeast 

func HeightAtLeast(target abi.ChainEpoch) ChainPredicate

HeightAtLeast returns a ChainPredicate that is satisfied when the chain height is equal or higher to the target.

type Closer added in v1.19.0 

type Closer func()

func CreateRPCServer 

func CreateRPCServer(t *testing.T, handler http.Handler, listener net.Listener) (*httptest.Server, multiaddr.Multiaddr, Closer)

type DealHarness 

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

func NewDealHarness 

func NewDealHarness(t *testing.T, client *TestFullNode, main *TestMiner, market *TestMiner) *DealHarness

NewDealHarness creates a test harness that contains testing utilities for deals.

func (*DealHarness) DefaultStartDealParams added in v1.11.1 

func (dh *DealHarness) DefaultStartDealParams() api.StartDealParams

func (*DealHarness) ExpectDealFailure added in v1.11.3 

func (dh *DealHarness) ExpectDealFailure(ctx context.Context, deal *cid.Cid, errs string) error

func (*DealHarness) ExtractFileFromCAR 

func (dh *DealHarness) ExtractFileFromCAR(ctx context.Context, file *os.File) string

func (*DealHarness) MakeOnlineDeal 

func (dh *DealHarness) MakeOnlineDeal(ctx context.Context, params MakeFullDealParams) (deal *cid.Cid, res *api.ImportRes, path string)

MakeOnlineDeal makes an online deal, generating a random file with the supplied seed, and setting the specified fast retrieval flag and start epoch on the storage deal. It returns when the deal is sealed.

TODO: convert input parameters to struct, and add size as an input param.

func (*DealHarness) PerformRetrieval 

func (dh *DealHarness) PerformRetrieval(ctx context.Context, deal *cid.Cid, root cid.Cid, carExport bool, offers ...api.QueryOffer) (path string)

func (*DealHarness) PerformRetrievalWithOrder added in v1.19.0 

func (dh *DealHarness) PerformRetrievalWithOrder(ctx context.Context, deal *cid.Cid, root cid.Cid, carExport bool, makeOrder func(api.QueryOffer, address.Address) api.RetrievalOrder, offers ...api.QueryOffer) (path string)

func (*DealHarness) RunConcurrentDeals 

func (dh *DealHarness) RunConcurrentDeals(opts RunConcurrentDealsOpts)

func (*DealHarness) StartDeal 

func (dh *DealHarness) StartDeal(ctx context.Context, dealParams api.StartDealParams) *cid.Cid

StartDeal starts a storage deal between the client and the miner.

func (*DealHarness) StartSealingWaiting 

func (dh *DealHarness) StartSealingWaiting(ctx context.Context)

func (*DealHarness) WaitDealPublished 

func (dh *DealHarness) WaitDealPublished(ctx context.Context, deal *cid.Cid)

WaitDealPublished waits until the deal is published.

func (*DealHarness) WaitDealSealed 

func (dh *DealHarness) WaitDealSealed(ctx context.Context, deal *cid.Cid, noseal, noSealStart bool, cb func())

WaitDealSealed waits until the deal is sealed.

func (*DealHarness) WaitDealSealedQuiet added in v1.13.1 

func (dh *DealHarness) WaitDealSealedQuiet(ctx context.Context, deal *cid.Cid, noseal, noSealStart bool, cb func())

WaitDealSealedQuiet waits until the deal is sealed, without logging anything.

type EVM added in v1.20.0 

type EVM struct{ *TestFullNode }

EVM groups EVM-related actions.

func (*EVM) AssertAddressBalanceConsistent added in v1.20.0 

func (e *EVM) AssertAddressBalanceConsistent(ctx context.Context, addr address.Address) big.Int

AssertAddressBalanceConsistent checks that the balance reported via the Filecoin and Ethereum operations for an f410 address is identical, returning the balance.

func (*EVM) ComputeContractAddress added in v1.20.0 

func (e *EVM) ComputeContractAddress(deployer ethtypes.EthAddress, nonce uint64) ethtypes.EthAddress

ComputeContractAddress computes the address of a contract deployed by the specified address with the specified nonce.

func (*EVM) DeployContract added in v1.20.0 

func (e *EVM) DeployContract(ctx context.Context, sender address.Address, bytecode []byte) eam.CreateReturn

func (*EVM) InvokeSolidity added in v1.20.0 

func (e *EVM) InvokeSolidity(ctx context.Context, sender address.Address, target address.Address, selector []byte, inputData []byte) *api.MsgLookup

func (*EVM) LoadEvents added in v1.20.0 

func (e *EVM) LoadEvents(ctx context.Context, eventsRoot cid.Cid) []types.Event

LoadEvents loads all events in an event AMT.

func (*EVM) NewAccount added in v1.20.0 

func (e *EVM) NewAccount() (*key.Key, ethtypes.EthAddress, address.Address)

func (*EVM) SignTransaction added in v1.20.0 

func (e *EVM) SignTransaction(tx *ethtypes.EthTxArgs, privKey []byte)

SignTransaction signs an Ethereum transaction in place with the supplied private key.

func (*EVM) SubmitTransaction added in v1.20.0 

func (e *EVM) SubmitTransaction(ctx context.Context, tx *ethtypes.EthTxArgs) ethtypes.EthHash

SubmitTransaction submits the transaction via the Eth endpoint.

type Ensemble 

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

Ensemble is a collection of nodes instantiated within a test.

Create a new ensemble with: 

ens := kit.NewEnsemble()

Create full nodes and miners: 

var full TestFullNode
var miner TestMiner
ens.FullNode(&full, opts...)       // populates a full node
ens.Miner(&miner, &full, opts...)  // populates a miner, using the full node as its chain daemon

It is possible to pass functional options to set initial balances, presealed sectors, owner keys, etc.

After the initial nodes are added, call `ens.Start()` to forge genesis and start the network. Mining will NOT be started automatically. It needs to be started explicitly by calling `BeginMining`.

Nodes also need to be connected with one another, either via `ens.Connect()` or `ens.InterconnectAll()`. A common inchantation for simple tests is to do: 

ens.InterconnectAll().BeginMining(blocktime)

You can continue to add more nodes, but you must always follow with `ens.Start()` to activate the new nodes.

The API is chainable, so it's possible to do a lot in a very succinct way: 

kit.NewEnsemble().FullNode(&full).Miner(&miner, &full).Start().InterconnectAll().BeginMining()

You can also find convenient fullnode:miner presets, such as 1:1, 1:2, and 2:1, e.g.: 

kit.EnsembleMinimal()
kit.EnsembleOneTwo()
kit.EnsembleTwoOne()

func NewEnsemble 

func NewEnsemble(t *testing.T, opts ...EnsembleOpt) *Ensemble

NewEnsemble instantiates a new blank Ensemble.

func (*Ensemble) AddInactiveMiner added in v1.19.0 

func (n *Ensemble) AddInactiveMiner(m *TestMiner)

func (*Ensemble) BeginMining 

func (n *Ensemble) BeginMining(blocktime time.Duration, miners ...*TestMiner) []*BlockMiner

BeginMining kicks off mining for the specified miners. If nil or 0-length, it will kick off mining for all enrolled and active miners. It also adds a cleanup function to stop all mining operations on test teardown.

func (*Ensemble) BeginMiningMustPost added in v1.14.0 

func (n *Ensemble) BeginMiningMustPost(blocktime time.Duration, miners ...*TestMiner) []*BlockMiner

func (*Ensemble) Connect 

func (n *Ensemble) Connect(from api.Net, to ...api.Net) *Ensemble

Connect connects one full node to the provided full nodes.

func (*Ensemble) FullNode 

func (n *Ensemble) FullNode(full *TestFullNode, opts ...NodeOpt) *Ensemble

FullNode enrolls a new full node.

func (*Ensemble) InterconnectAll 

func (n *Ensemble) InterconnectAll() *Ensemble

InterconnectAll connects all miners and full nodes to one another.

func (*Ensemble) Miner 

func (n *Ensemble) Miner(minerNode *TestMiner, full *TestFullNode, opts ...NodeOpt) *Ensemble

func (*Ensemble) MinerEnroll added in v1.19.0 

func (n *Ensemble) MinerEnroll(minerNode *TestMiner, full *TestFullNode, opts ...NodeOpt) *Ensemble

Miner enrolls a new miner, using the provided full node for chain interactions.

func (*Ensemble) Mocknet added in v1.15.1 

func (n *Ensemble) Mocknet() mocknet.Mocknet

Mocknet returns the underlying mocknet.

func (*Ensemble) NewPrivKey added in v1.19.0 

func (n *Ensemble) NewPrivKey() (libp2pcrypto.PrivKey, peer.ID)

func (*Ensemble) Start 

func (n *Ensemble) Start() *Ensemble

Start starts all enrolled nodes.

func (*Ensemble) Worker added in v1.15.2 

func (n *Ensemble) Worker(minerNode *TestMiner, worker *TestWorker, opts ...NodeOpt) *Ensemble

Worker enrolls a new worker, using the provided full node for chain interactions.

type EnsembleOpt 

type EnsembleOpt func(opts *ensembleOpts) error

func Account 

func Account(key *key.Key, balance abi.TokenAmount) EnsembleOpt

Account sets up an account at genesis with the specified key and balance.

func GenesisNetworkVersion added in v1.11.2 

func GenesisNetworkVersion(nv network.Version) EnsembleOpt

GenesisNetworkVersion sets the network version of genesis.

func LatestActorsAt 

func LatestActorsAt(upgradeHeight abi.ChainEpoch) EnsembleOpt

func MockProofs 

func MockProofs() EnsembleOpt

MockProofs activates mock proofs for the entire ensemble.

func RootVerifier 

func RootVerifier(key *key.Key, balance abi.TokenAmount) EnsembleOpt

RootVerifier specifies the key to be enlisted as the verified registry root, as well as the initial balance to be attributed during genesis.

func SDRUpgradeAt 

func SDRUpgradeAt(calico, persian abi.ChainEpoch) EnsembleOpt

func TurboUpgradeAt added in v1.11.2 

func TurboUpgradeAt(upgradeHeight abi.ChainEpoch) EnsembleOpt

func UpgradeSchedule added in v1.11.2 

func UpgradeSchedule(upgrades ...stmgr.Upgrade) EnsembleOpt

type GeneratedDAGOpts added in v1.15.1 

type GeneratedDAGOpts struct {
	ChunkSize int64
	Maxlinks  int
}

type ItestdNotif added in v1.15.1 

type ItestdNotif struct {
	NodeType string // api env var name
	TestName string
	Api      string
}

type Libp2p added in v1.19.0 

type Libp2p struct {
	PeerID  peer.ID
	PrivKey libp2pcrypto.PrivKey
}

type MakeFullDealParams 

type MakeFullDealParams struct {
	Rseed                    int
	FastRet                  bool
	StartEpoch               abi.ChainEpoch
	UseCARFileForStorageDeal bool

	// SuspendUntilCryptoeconStable suspends deal-making, until cryptoecon
	// parameters are stabilised. This affects projected collateral, and tests
	// will fail in network version 13 and higher if deals are started too soon
	// after network birth.
	//
	// The reason is that the formula for collateral calculation takes
	// circulating supply into account:
	//
	//   [portion of power this deal will be] * [~1% of tokens].
	//
	// In the first epochs after genesis, the total circulating supply is
	// changing dramatically in percentual terms. Therefore, if the deal is
	// proposed too soon, by the time it gets published on chain, the quoted
	// provider collateral will no longer be valid.
	//
	// The observation is that deals fail with:
	//
	//   GasEstimateMessageGas error: estimating gas used: message execution
	//   failed: exit 16, reason: Provider collateral out of bounds. (RetCode=16)
	//
	// Enabling this will suspend deal-making until the network has reached a
	// height of 300.
	SuspendUntilCryptoeconStable bool
}

type MinerSubsystem added in v1.11.1 

type MinerSubsystem int
const (
	SMarkets MinerSubsystem = 1 << iota
	SMining
	SSealing
	SSectorStorage

	MinerSubsystems = iota
)

func (MinerSubsystem) Add added in v1.11.1 

func (ms MinerSubsystem) Add(single MinerSubsystem) MinerSubsystem

func (MinerSubsystem) All added in v1.11.1 

func (ms MinerSubsystem) All() [MinerSubsystems]bool

func (MinerSubsystem) Has added in v1.11.1 

func (ms MinerSubsystem) Has(single MinerSubsystem) bool

type MockCLI 

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

func NewMockCLI 

func NewMockCLI(ctx context.Context, t *testing.T, cmds []*lcli.Command, nodeType api.NodeType) *MockCLI

func (*MockCLI) Client 

func (c *MockCLI) Client(addr multiaddr.Multiaddr) *MockCLIClient

type MockCLIClient 

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

MockCLIClient runs commands against a particular node

func (*MockCLIClient) RunCmd 

func (c *MockCLIClient) RunCmd(input ...string) string

func (*MockCLIClient) RunCmdRaw 

func (c *MockCLIClient) RunCmdRaw(input ...string) (string, error)

func (*MockCLIClient) RunInteractiveCmd 

func (c *MockCLIClient) RunInteractiveCmd(cmd []string, interactive []string) string

type NodeOpt 

type NodeOpt func(opts *nodeOpts) error

NodeOpt is a functional option for test nodes.

func ConstructorOpts 

func ConstructorOpts(extra ...node.Option) NodeOpt

ConstructorOpts are Lotus node constructor options that are passed as-is to the node.

func DisableLibp2p added in v1.11.1 

func DisableLibp2p() NodeOpt

func EthTxHashLookup 

func EthTxHashLookup() NodeOpt

func FsRepo added in v1.17.1 

func FsRepo() NodeOpt

func HistoricFilterAPI 

func HistoricFilterAPI(dbpath string) NodeOpt

func LiteNode 

func LiteNode() NodeOpt

LiteNode specifies that this node will be a lite node. Only relevant when creating a fullnode.

func MainMiner added in v1.11.1 

func MainMiner(m *TestMiner) NodeOpt

func MutateSealingConfig added in v1.15.2 

func MutateSealingConfig(mut func(sc *config.SealingConfig)) NodeOpt

func NoStorage added in v1.17.1 

func NoStorage() NodeOpt

NoStorage initializes miners with no writable storage paths (just read-only preseal paths)

func OwnerAddr 

func OwnerAddr(wk *key.Key) NodeOpt

OwnerAddr sets the owner address of a miner. Only relevant when creating a miner.

func OwnerBalance 

func OwnerBalance(balance abi.TokenAmount) NodeOpt

OwnerBalance specifies the balance to be attributed to a miner's owner account. Only relevant when creating a miner.

func PresealSectors 

func PresealSectors(sectors int) NodeOpt

PresealSectors specifies the amount of preseal sectors to give to a miner at genesis. Only relevant when creating a miner.

func RealTimeFilterAPI 

func RealTimeFilterAPI() NodeOpt

func SectorSize added in v1.11.3 

func SectorSize(sectorSize abi.SectorSize) NodeOpt

SectorSize sets the sector size for this miner. Start() will populate the corresponding proof type depending on the network version (genesis network version if the Ensemble is unstarted, or the current network version if started).

func SplitstoreDiscard added in v1.17.1 

func SplitstoreDiscard() NodeOpt

func SplitstoreMessges added in v1.19.0 

func SplitstoreMessges() NodeOpt

func SplitstoreUniversal added in v1.17.1 

func SplitstoreUniversal() NodeOpt

func ThroughRPC 

func ThroughRPC() NodeOpt

ThroughRPC makes interactions with this node throughout the test flow through the JSON-RPC API.

func WithAllSubsystems added in v1.11.1 

func WithAllSubsystems() NodeOpt

func WithAssigner added in v1.17.0 

func WithAssigner(a string) NodeOpt

func WithCfgOpt added in v1.17.1 

func WithCfgOpt(opt CfgOption) NodeOpt

func WithDisallowRemoteFinalize added in v1.17.0 

func WithDisallowRemoteFinalize(d bool) NodeOpt

func WithMaxStagingDealsBytes added in v1.11.3 

func WithMaxStagingDealsBytes(size int64) NodeOpt

func WithNoLocalSealing added in v1.15.2 

func WithNoLocalSealing(nope bool) NodeOpt

func WithSubsystems added in v1.11.1 

func WithSubsystems(systems ...MinerSubsystem) NodeOpt

func WithTaskTypes added in v1.15.2 

func WithTaskTypes(tt []sealtasks.TaskType) NodeOpt

func WithWorkerName added in v1.17.1 

func WithWorkerName(n string) NodeOpt

func WithWorkerStorage added in v1.15.2 

func WithWorkerStorage(transform func(paths.Store) paths.Store) NodeOpt

type OptBuilder 

type OptBuilder func(activeNodes []*TestFullNode) node.Option

OptBuilder is used to create an option after some other node is already active. Takes all active nodes as a parameter.

type RunConcurrentDealsOpts 

type RunConcurrentDealsOpts struct {
	N                        int
	FastRetrieval            bool
	CarExport                bool
	StartEpoch               abi.ChainEpoch
	UseCARFileForStorageDeal bool
	IndexProvider            *shared_testutil.MockIndexProvider
}

type SchedInfo added in v1.20.0 

type SchedInfo struct {
	CallToWork   struct{}
	EarlyRet     interface{}
	ReturnedWork interface{}
	SchedInfo    struct {
		OpenWindows []string
		Requests    []struct {
			Priority int
			SchedId  uuid.UUID
			Sector   struct {
				Miner  int
				Number int
			}
			TaskType string
		}
	}
	Waiting interface{}
}

comes from https://github.com/filecoin-project/lotus/blob/8ba4355cabd25e5f65261aaa561ff676321ffbd8/storage/sealer/manager.go#L1226 todo: have this defined in one place

type TestDealState 

type TestDealState int

func CategorizeDealState 

func CategorizeDealState(dealStatus string) TestDealState

CategorizeDealState categorizes deal states into one of three states: Complete, InProgress, Failed.

type TestFullNode 

type TestFullNode struct {
	v1api.FullNode

	// ListenAddr is the address on which an API server is listening, if an
	// API server is created for this Node.
	ListenAddr multiaddr.Multiaddr
	ListenURL  string
	DefaultKey *key.Key

	Pkey *Libp2p

	Stop node.StopFunc
	// contains filtered or unexported fields
}

TestFullNode represents a full node enrolled in an Ensemble.

func MergeFullNodes added in v1.19.0 

func MergeFullNodes(fullNodes []*TestFullNode) *TestFullNode

func (*TestFullNode) AssertActorType added in v1.20.0 

func (f *TestFullNode) AssertActorType(ctx context.Context, addr address.Address, actorType string)

AssertActorType verifies that the supplied address is an actor of the specified type (as per its manifest key).

func (*TestFullNode) AssignPrivKey added in v1.19.0 

func (f *TestFullNode) AssignPrivKey(pkey *Libp2p)

func (*TestFullNode) ClientImportCARFile added in v1.11.2 

func (f *TestFullNode) ClientImportCARFile(ctx context.Context, rseed int, size int) (res *api.ImportRes, carv1FilePath string, origFilePath string)

func (*TestFullNode) CreateImportFile 

func (f *TestFullNode) CreateImportFile(ctx context.Context, rseed int, size int) (res *api.ImportRes, path string)

CreateImportFile creates a random file with the specified seed and size, and imports it into the full node.

func (*TestFullNode) EVM added in v1.20.0 

func (f *TestFullNode) EVM() *EVM

func (TestFullNode) Shutdown added in v1.19.0 

func (f TestFullNode) Shutdown(ctx context.Context) error

func (*TestFullNode) WaitForSectorActive added in v1.15.2 

func (f *TestFullNode) WaitForSectorActive(ctx context.Context, t *testing.T, sn abi.SectorNumber, maddr address.Address)

func (*TestFullNode) WaitMsg added in v1.11.1 

func (f *TestFullNode) WaitMsg(ctx context.Context, msg cid.Cid)

func (*TestFullNode) WaitTillChain 

func (f *TestFullNode) WaitTillChain(ctx context.Context, pred ChainPredicate) *types.TipSet

WaitTillChain waits until a specified chain condition is met. It returns the first tipset where the condition is met.

type TestMiner 

type TestMiner struct {
	api.StorageMiner

	BaseAPI api.StorageMiner

	// ListenAddr is the address on which an API server is listening, if an
	// API server is created for this Node
	ListenAddr multiaddr.Multiaddr

	ActorAddr address.Address
	OwnerKey  *key.Key
	MineOne   func(context.Context, miner.MineReq) error
	Stop      func(context.Context) error

	FullNode       *TestFullNode
	PresealDir     string
	PresealSectors int

	Libp2p struct {
		PeerID  peer.ID
		PrivKey libp2pcrypto.PrivKey
	}

	RemoteListener net.Listener
	// contains filtered or unexported fields
}

TestMiner represents a miner enrolled in an Ensemble.

func (*TestMiner) AddStorage 

func (tm *TestMiner) AddStorage(ctx context.Context, t *testing.T, conf func(*storiface.LocalStorageMeta)) storiface.ID

func (*TestMiner) FlushSealingBatches 

func (tm *TestMiner) FlushSealingBatches(ctx context.Context)

func (*TestMiner) PledgeSectors 

func (tm *TestMiner) PledgeSectors(ctx context.Context, n, existing int, blockNotif <-chan struct{})

func (*TestMiner) SchedInfo added in v1.20.0 

func (tm *TestMiner) SchedInfo(ctx context.Context) SchedInfo

func (*TestMiner) SectorsListNonGenesis added in v1.17.1 

func (tm *TestMiner) SectorsListNonGenesis(ctx context.Context) ([]abi.SectorNumber, error)

func (*TestMiner) SetControlAddresses added in v1.11.1 

func (tm *TestMiner) SetControlAddresses(addrs ...addr.Address)

func (*TestMiner) StartPledge 

func (tm *TestMiner) StartPledge(ctx context.Context, n, existing int, blockNotif <-chan struct{}) map[abi.SectorNumber]struct{}

func (*TestMiner) WaitSectorsProving added in v1.14.0 

func (tm *TestMiner) WaitSectorsProving(ctx context.Context, toCheck map[abi.SectorNumber]struct{})

func (*TestMiner) WaitSectorsProvingAllowFails added in v1.17.2 

func (tm *TestMiner) WaitSectorsProvingAllowFails(ctx context.Context, toCheck map[abi.SectorNumber]struct{}, okFails map[api.SectorState]struct{})

type TestWorker added in v1.15.2 

type TestWorker struct {
	api.Worker

	// ListenAddr is the address on which an API server is listening, if an
	// API server is created for this Node
	ListenAddr multiaddr.Multiaddr

	Stop func(context.Context) error

	FetchHandler   http.HandlerFunc
	MinerNode      *TestMiner
	RemoteListener net.Listener
	// contains filtered or unexported fields
}

TestWorker represents a worker enrolled in an Ensemble.

func (*TestWorker) AddStorage added in v1.17.1 

func (tm *TestWorker) AddStorage(ctx context.Context, t *testing.T, conf func(*storiface.LocalStorageMeta)) storiface.ID

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.