cli

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

type BugreportRunner struct {
	Collect       func(ctx context.Context, serial, outputPath string) error
	CollectIOS    func(ctx context.Context, udid, outputPath string) error
	ResolveSerial func() (string, error)
}

type CheckSyntaxRunner struct {
	Checker Checker
	Getwd   func() (string, error)
}

type Checker interface {
	Check(context.Context, Source) error
}

type CryptoRandom struct{}

type DeviceSession struct {
	Driver device.Driver
	// OutputDirectory receives screenshots and other run artifacts.
	OutputDirectory string
	// BaseDirectory resolves flow resources such as runScript files.
	BaseDirectory string
	// Clock is optional; a nil clock uses the wall clock. Tests supply their
	// own so a flow's waits do not take real time.
	Clock engine.Clock
	// ExecutionID is optional; a blank one is derived from the run's own start.
	ExecutionID string
	// Shard is which share of the run this session executes. It is what the
	// reserved FLOWBATON_SHARD_* and FLOWBATON_DEVICE_UDID variables are built
	// from, so a flow can report where it ran.
	Shard Shard
}

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

type DriverSetupRunner struct {
	Build func(ctx context.Context, platform, teamID string) error
}

type GenerateCompletionRunner struct{}

type HierarchyRunner struct {
	Fetch func(ctx context.Context, platform, udid string, appIDs []string) (device.TreeNode, error)
}

type ImageChecker struct{}

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

type ListDevicesRunner struct {
	IOS     func(context.Context) ([]ios.Device, error)
	Android func(context.Context) ([]android.Device, error)
}

type MCPRunner struct {
	Checker     Checker
	ListDevices ListDevicesRunner
	Hierarchy   HierarchyRunner
	Query       QueryRunner
}

type ParserChecker struct {
	Preflight Preflight
}

type Preflight interface {
	Check(context.Context, Source, model.Flow) error
}

type QueryRunner struct {
	Fetch func(ctx context.Context, platform, udid, appID, expression string) ([]device.TreeNode, error)
}

type RecordRunner struct {
	NewSession func(Shard, TestOptions) (TestSession, error)
}

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

type SessionFactory func(Shard, TestOptions) (TestSession, error)

type Shard struct {
	// Index is 0-based; the human-facing number is Index+1.
	Index int
	// Roots are the flow paths this shard runs, in the plan's own order.
	Roots []string
	// Device is the udid this shard runs on. It is blank for an unsharded run
	// with no --device, so the driver keeps saying which flag is missing.
	Device string
	// OutputDirectory is where this shard's artifacts go. The runner fills it
	// in after planning; planning itself has no opinion about the filesystem.
	OutputDirectory string
	// DriverPort is the loopback port this shard's driver talks to. Shard 1
	// keeps the contract's port; later shards get one each, because two shards
	// on one port drive the same runner.
	DriverPort int
}

type Source struct {
	Name    string
	BaseDir string
	Data    []byte
}

type StartDeviceRunner struct {
	// Boot boots an existing iOS simulator by udid (default: simctl boot).
	Boot func(ctx context.Context, platform, udid string) error
	// ListAVDs enumerates installed Android AVD names (default: emulator -list-avds).
	ListAVDs func(ctx context.Context) ([]string, error)
	// LaunchAVD launches an Android AVD by name (default: emulator -avd <name>).
	LaunchAVD func(ctx context.Context, avd string) error
	// CreateSim creates a new iOS simulator and returns its udid (default: simctl create).
	CreateSim func(ctx context.Context, osVersion, deviceLocale string) (string, error)
	// CreateAVD creates a new Android AVD and returns its name (default: avdmanager create).
	CreateAVD func(ctx context.Context, osVersion, deviceLocale string) (string, error)
}

type TestOptions struct {
	Roots []string

	ConfigPath  string
	Env         map[string]string
	IncludeTags []string
	ExcludeTags []string

	Format        string
	TestSuiteName string
	Output        string

	DebugOutput        string
	TestOutputDir      string
	FlattenDebugOutput bool
	Continuous         bool
	Headless           bool
	Analyze            bool
	ReinstallDriver    bool
	ScreenSize         string
	APIURL             string
	APIKey             string
	AppleTeamID        string
	Platform           string
	Devices            []string
	ShardSplit         int
	ShardAll           int

	// RecordTo is where `record` wants the video. It is NOT parsed from a
	// command line: the `test` command has no such flag. RecordRunner sets it.
	RecordTo string

	// SequencedRoots and ContinueOnFailure come from the workspace's
	// executionOrder, not from argv. They decide whether a failed flow ends
	// the suite; see engine.Dependencies for the rule.
	SequencedRoots    int
	ContinueOnFailure bool
	// contains filtered or unexported fields
}

type TestRunner struct {
	// NewSession acquires one shard's device and executes its flows. It is
	// injected because no production session can be built without a device; a
	// nil factory falls back to the real one.
	NewSession SessionFactory
	Loader     capability.FlowLoader
	// Clock is optional; nil uses the wall clock. It fixes the run's own notion
	// of now, which both the default output directory and the report timestamp
	// read, so two identical runs render identical bytes.
	Clock engine.Clock
	// Environ is optional; nil reads the process environment. It supplies the
	// shell's FLOWBATON_ variables, per specs/01-core-engine.md:101.
	Environ func() []string
	// AllocatePort is optional; nil asks the operating system for an ephemeral
	// port. Injected so a test can pin the ports a sharded run picks.
	AllocatePort func() (int, error)
	// PollInterval is how often continuous mode re-stamps its watch set; zero
	// uses defaultPollInterval. Injected so a test does not wait on it.
	PollInterval time.Duration
	// RecordTo is set by RecordRunner, never by argv. See TestOptions.RecordTo.
	RecordTo string
}

type TestSession interface {
	Execute(context.Context, *engine.Program, TestOptions) ([]engine.FlowResult, error)
}

type UnsupportedRecordingController struct{}

type UsageError struct {
	Message string
}