harness

type Approval ¶

type Approval struct {
	Err      error
	Requests []capkit.ApprovalRequest
}

Approval is an approving-by-default capkit.Approver.

func (a *Approval) Require(_ context.Context, req capkit.ApprovalRequest) error

type Artifacts ¶

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

Artifacts is an in-memory capkit.ArtifactStore.

func (a *Artifacts) Delete(_ context.Context, path string) error

func (a *Artifacts) Get(_ context.Context, path string) ([]byte, error)

func (a *Artifacts) Put(_ context.Context, name string, data []byte) (string, error)

type Audit ¶

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

Audit records every capkit.AuditEvent it receives.

func (a *Audit) Events() []capkit.AuditEvent

func (a *Audit) Record(_ context.Context, ev capkit.AuditEvent)

type Binaries ¶

type Binaries struct {
	Path  string
	State capkit.BinaryStatus
	Err   error
}

Binaries is a scripted capkit.BinaryManager reporting every binary installed.

func (b *Binaries) Ensure(context.Context, string, string) (string, capkit.BinaryStatus, error)

func (b *Binaries) Status(context.Context, string) (capkit.BinaryStatus, error)

func (b *Binaries) Update(context.Context, string, string) (capkit.BinaryStatus, error)

type Clock ¶

type Clock struct {
	Now_ time.Time
	Step time.Duration
	// contains filtered or unexported fields
}

Clock is a manual clock. Every call to Now advances by Step, so a test that needs distinct timestamps gets them without sleeping.

func NewClock(t time.Time) *Clock

func (c *Clock) Advance(d time.Duration)

func (c *Clock) Now() time.Time

func (c *Clock) Set(t time.Time)

type CloudSignRequest ¶

type CloudSignRequest struct {
	Request   capkit.Request
	AccessKey string
	SecretKey string
	At        time.Time
}

CloudSignRequest is one recorded signing request.

type CloudSigner ¶

type CloudSigner struct {
	// Signature is the value embedded in the Authorization header.
	Signature string
	// AccessKey, when set, overrides the credential echoed into the header.
	AccessKey string
	Err       error
	// contains filtered or unexported fields
}

CloudSigner is a scripted cloud request signer. It records every request it was asked to sign and stamps a deterministic Authorization header, so a cloud tool can be exercised offline: the test asserts on what would have been sent without ever reaching a vendor API.

It satisfies cloudkit's Signer interface structurally, which keeps this package free of kit imports.

func (s *CloudSigner) SignRequest(req capkit.Request, accessKey, secretKey string, now time.Time) (capkit.Request, error)

func (s *CloudSigner) Signed() []CloudSignRequest

type Engine ¶

type Engine struct {
	KindName string
	Result   capkit.Result
	Err      error
}

Engine is a scripted capkit.TemplateEngine.

func (e *Engine) Execute(context.Context, []capkit.TemplateRef, capkit.Target, map[string]any) (capkit.Result, error)

func (e *Engine) Kind() string

type Evidence ¶

type Evidence struct {
	Prefix string
	Err    error
	// contains filtered or unexported fields
}

Evidence stores every capkit.Evidence it is handed and returns "<Prefix><n>".

func (e *Evidence) Record(_ context.Context, ev capkit.Evidence) (string, error)

func (e *Evidence) Records() []capkit.Evidence

type Fingerprints ¶

type Fingerprints struct {
	Result []capkit.Fingerprint
	Err    error
}

Fingerprints is a scripted capkit.FingerprintProvider.

func (f *Fingerprints) Fingerprint(context.Context, capkit.Target) ([]capkit.Fingerprint, error)

type HTTP ¶

type HTTP struct {
	// Default answers any request no route matches.
	Default Route
	// Routes are checked in order before Default.
	Routes []Route
	// Queue answers the first len(Queue) calls in order, before Routes and
	// Default apply, and is consumed as it is used. It exists for protocol-level
	// sequences a route table cannot express — "the invocation does not exist
	// yet on the first poll, succeeds on the second" — where the answer depends
	// on how many calls came before rather than on the request itself.
	Queue []Route
	// Err fails every call regardless of routes.
	Err error
	// contains filtered or unexported fields
}

HTTP is a scripted capkit.HTTPDoer and capkit.Fetcher. It answers from a route table, falling back to the default response, and records every request in call order.

func NewHTTP(status int, body string) *HTTP

func NewHTTPJSON(body string) *HTTP

func (h *HTTP) Calls() int

func (h *HTTP) Do(ctx context.Context, req capkit.Request) (*capkit.Response, error)

func (h *HTTP) Fetch(ctx context.Context, req capkit.Request) (*capkit.Response, error)

func (h *HTTP) Last() (capkit.Request, bool)

func (h *HTTP) Requests() []capkit.Request

type IDs ¶

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

IDs is a deterministic capkit.IDGenerator: the n-th call for a prefix returns "<prefix>-<n>".

func (g *IDs) New(prefix string) string

type Limiter ¶

type Limiter struct {
	Err      error
	Acquired []string
}

Limiter is a non-blocking capkit.Limiter that records the keys it admitted.

func (l *Limiter) Acquire(_ context.Context, key string, _ capkit.RateLimitSpec) (func(), error)

type Logger ¶

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

Logger keeps every line it is given.

func (l *Logger) Error(msg string, kv ...any)

func (l *Logger) Info(msg string, kv ...any)

func (l *Logger) Lines() []string

func (l *Logger) Warn(msg string, kv ...any)

type Ports ¶

type Ports struct {
	HTTP     *HTTP
	Fetcher  *HTTP
	Scope    *Scope
	Approval *Approval
	Limiter  *Limiter
	Audit    *Audit
	Evidence *Evidence
	Settings *Settings
	Sealer   Sealer
	Logger   *Logger
	Clock    *Clock
	IDs      *IDs
	Process  *Process
	Artifact *Artifacts
	Binaries *Binaries

	Fingerprints *Fingerprints
	Templates    *Templates
	Engine       *Engine
	Sessions     *Sessions
}

Ports is the assembled fake port set. Fields are exposed so a test can swap one fake for a stricter one.

func NewPorts() *Ports

func (p *Ports) Deps() capkit.Deps

type Process ¶

type Process struct {
	Stdout   []byte
	Stderr   []byte
	ExitCode int
	Err      error
	// Handler, when set, overrides the preset and answers per spec.
	Handler func(capkit.ProcessSpec) (*capkit.ProcessResult, error)
	// contains filtered or unexported fields
}

Process is a scripted capkit.ProcessRunner: every Run returns the preset stdout/stderr/exit code and records the spec.

func (p *Process) Calls() []capkit.ProcessSpec

func (p *Process) Last() (capkit.ProcessSpec, bool)

func (p *Process) Run(_ context.Context, spec capkit.ProcessSpec) (*capkit.ProcessResult, error)

type Route ¶

type Route struct {
	Match   string
	Status  int
	Body    string
	Headers map[string][]string
	Err     error
}

Route is one scripted HTTP answer. When Match is non-empty only requests whose URL contains it take this route; otherwise it is the fallback.

type Scope ¶

type Scope struct {
	Denied  []string
	Err     error
	Checked []capkit.Target
}

Scope is a permissive-by-default capkit.ScopeChecker. Denied lists the hosts that must be refused; Err denies everything.

func (s *Scope) Check(_ context.Context, t capkit.Target) error

type Sealer ¶

type Sealer struct{ Key byte }

Sealer is a reversible XOR sealer for tests. It is not cryptographic and must never be used outside a test.

func (s Sealer) Open(sealed string) (string, error)

func (s Sealer) Seal(plain string) (string, error)

type Session ¶

type Session struct {
	SessionInfo capkit.SessionInfo
	Stdout      string
	Stderr      string
	ExitCode    int
	Err         error
	// contains filtered or unexported fields
}

Session is a scripted capkit.Session: Exec answers with the preset output.

func NewSession(id string) *Session

func (s *Session) Calls() []string

func (s *Session) Close() error

func (s *Session) Exec(_ context.Context, cmd string, _ capkit.ExecOpts) (capkit.Output, error)

func (s *Session) Info() capkit.SessionInfo

type Sessions ¶

type Sessions struct {
	OpenErr error
	// contains filtered or unexported fields
}

Sessions is an in-memory capkit.SessionManager. NewSessions starts empty; NewSessionsWith pre-registers the given sessions.

func NewSessions() *Sessions

func NewSessionsWith(list ...*Session) *Sessions

func (m *Sessions) Add(s *Session)

func (m *Sessions) Close(id string) error

func (m *Sessions) Get(id string) (capkit.Session, bool)

func (m *Sessions) List() []capkit.SessionInfo

func (m *Sessions) NextID(prefix string) string

func (m *Sessions) Open(_ context.Context, spec capkit.SessionSpec) (capkit.SessionInfo, error)

type Settings ¶

type Settings struct {
	Strings map[string]string
	Bools   map[string]bool
	Ints    map[string]int64
}

Settings is an in-memory capkit.Settings.

func NewSettings() *Settings

func (s *Settings) GetBool(_ context.Context, key string) (bool, bool)

func (s *Settings) GetInt(_ context.Context, key string) (int64, bool)

func (s *Settings) GetString(_ context.Context, key string) (string, bool)

type Templates ¶

type Templates struct {
	Refs []capkit.TemplateRef
	Err  error
}

Templates is an in-memory capkit.TemplateCatalog.

func (t *Templates) Get(_ context.Context, id string) (capkit.TemplateRef, bool, error)

func (t *Templates) Search(context.Context, capkit.TemplateQuery) ([]capkit.TemplateRef, error)