AccountFixture returns a randomly generated account.

AccountKeyDefaultFixture returns a randomly generated ECDSA/SHA3 account key.

AccountKeyFixture returns a randomly generated account key.

AlterTransactionForCluster modifies a transaction nonce until it is assigned to the target cluster.

AssertClosesBefore asserts that the given channel closes before the duration expires.

AssertEqualBlocksLenAndOrder asserts that both a segment of blocks have the same len and blocks are in the same order.

AssertErrSubstringMatch asserts that two errors match with substring checking on the Error method (`expected` must be a substring of `actual`, to account for the actual error being wrapped).

AssertNotClosesBefore asserts that the given channel does not close before the duration expires.

AssertReturnsBefore asserts that the given function returns before the duration expires.

AsSlashable returns the input message T, wrapped as a flow.Slashable instance with a random origin ID.

BlockEventsFixture returns a block events model populated with random events of length n.

BootstrapFixture generates all the artifacts necessary to bootstrap the protocol state.

ChainFixture creates a list of blocks that forms a chain.

ChainFixtureFrom creates a chain of blocks starting from a given parent block, the total number of blocks in the chain is specified by the given count.

ChunkDataPackRequestFixture creates a chunk data request with some default values, i.e., one agree execution node, one disagree execution node, and height of zero.

ChunkDataPackRequestListFixture creates and returns a list of chunk data pack requests fixtures.

ChunkDataResponseMessageListFixture creates a list of chunk data response messages each with a single-transaction collection, and random chunk ID.

ChunkDataResponseMsgFixture creates a chunk data response message with a single-transaction collection, and random chunk ID.

ChunkStatusListFixture receives an execution result, samples `n` chunks out of it and creates a chunk status for them.

ChunkStatusListToChunkLocatorFixture extracts chunk locators from a list of chunk statuses.

ClusterAssignment creates an assignment list with n clusters and with nodes evenly distributed among clusters.

ClusterBlockWithParent creates a new cluster consensus block that is valid with respect to the given parent block.

CompleteIdentitySet takes a number of identities and completes the missing roles.

CrashTest safely tests functions that crash (as the expected behavior) by checking that running the function creates an error and an expected error message.

CrashTestWithExpectedStatus checks for the test crashing with a specific exit code.

CreateNParticipantsWithMyRole creates a list of identities from given roles.

DKGBroadcastMessageFixture creates a single DKG broadcast message with random fields.

DKGMessageFixture creates a single DKG message with random fields.

EnsureEventsIndexSeq checks if values of given event index sequence are monotonically increasing.

EpochSetupFixture creates a valid EpochSetup with default properties for testing.

EventFixture returns an event.

FinalizedProtocolStateWithParticipants returns a protocol state with finalized participants.

GenerateRandomStringWithLen returns a string of random alpha characters of the provided length.

GetFlowProtocolEventID returns the event ID for the event provided.

HeadersFromMap creates a storage header mock that backed by a given map.

IdentityFixture returns a node identity.

IdentityListFixture returns a list of node identity objects.

IdentityWithNetworkingKeyFixture returns a node identity and networking private key.

Logger returns a zerolog use -vv flag to print debugging logs for tests.

go:noinline.

NetworkCodec returns cbor codec.

NetworkingPrivKeyFixture returns random ECDSAP256 private key.

NetworkSlashingViolationsConsumer returns a slashing violations consumer for network middleware.

NetworkTopology returns the default topology for testing purposes.

NewClusterStateChecker returns a state checker for the given state.

NewEpochBuilder returns a new EpochBuilder which will build epochs using the given states.

NewProtectedMap returns a new ProtectedMap with the given types.

NewTestTime returns new TestTime.

NoopTxScript returns a Cadence script for a no-op transaction.

PrintHeapInfo prints heap object allocation through given logger.

PrivateKeyFixture returns a random private key with specified signature algorithm and seed length.

PrivateKeyFixtureByIdentifier returns a private key for a given node.

ReadyDoneify sets up a generated mock to respond to Ready and Done lifecycle methods.

ReconnectBlocksAndReceipts re-computes each block's PayloadHash and ParentID so that all the blocks are connected.

RequireCloseBefore requires that the given channel returns before the duration expires.

RequireClosed is a test helper function that fails the test if channel `ch` is not closed.

RequireComponentsDoneBefore invokes the done method of each of the input components concurrently, and fails the test if any components shutdown takes longer than the specified duration.

RequireComponentsReadyBefore invokes the ready method of each of the input components concurrently, and fails the test if any components startup takes longer than the specified duration.

RequireConcurrentCallsReturnBefore is a test helper that runs function `f` count-many times concurrently, and requires all invocations to return within duration.

RequireNeverClosedWithin is a test helper function that fails the test if channel `ch` is closed before the determined duration.

RequireNeverReturnBefore is a test helper that tries invoking function `f` and fails the test if either: - function `f` is not invoked within 1 second.

RequireNotClosed is a test helper function that fails the test if channel `ch` is closed.

RequireReturnsBefore requires that the given function returns before the duration expires.

RootSnapshotFixture returns a snapshot representing a root chain state, for example one as returned from BootstrapFixture.

RunWithTypedBadgerDB creates a Badger DB that is passed to f and closed after f returns.

SealBlock seals a block by building two blocks on it, the first containing a receipt for the block, the second containing a seal for the block.

SeedFixture returns a random []byte with length n.

SeedFixtures returns a list of m random []byte, each having length n.

StakingPrivKeyFixture returns a random BLS12381 private keyf.

TransactionForCluster generates a transaction that will be assigned to the target cluster ID.

VerifiableChunkDataFixture returns a complete verifiable chunk with an execution receipt referencing the block/collections.

WithAddress sets the network address of identity fixture.

WithAllRoles can be used used to ensure an IdentityList fixtures contains all the roles required for a valid genesis block.

Same as above, but omitting a certain role for cases where we are manually setting up nodes or a particular role.

WithAllTheFixins ensures a payload contains no empty slice fields.

WithApproximateSize sets the ChunkDataResponse to be approximately bytes in size.

WithExecutionResults will add execution results to payload.

WithNetworkingKey sets the networking public key of identity fixture.

WithNodeID adds a node ID with the given first byte to an identity.

WithRandomPublicKeys adds random public keys to an identity.

WithReceiptsAndNoResults will add receipt to payload only.

WithRole adds a role to an identity fixture.

WithStakingPubKey adds a staking public key to the identity.

WithWeight sets the weight on an identity fixture.

Pre-calculated state commitment with root account with the above private key.

uses code that has been deprecated / disabled.

flaky.

long running.

requires the environment to be configured with GCP credentials.

resource intensive test.

not fully implemented or broken and needs to be fixed.

ClusterStateChecker is a test utility for checking cluster state.

EpochBuilder is a testing utility for building epochs into chain state.

EpochHeights is a structure caching the results of building an epoch with EpochBuilder.

LoggerHook implements the zerolog.Hook interface and can be used to capture logs for testing purposes.

MockEntity implements a bare minimum entity for sake of test.

ProtectedMap is a thread-safe map.

TestTime is a fake time used for testing.