fake.go

// Package legatustest provides test doubles for the legatus core: a scripted

// Conn and a Dialer that hands them out per host. Shared so engine, steps, and

// sync tests do not each reimplement a fake (GPC8). The doubles are safe for the

// concurrent use the Runner makes of them under fan-out.

package legatustest

import (

	"context"

	"io"

	"sync"

	"go.bigb.es/auxilia/legatus"

)

// FakeConn is a scripted legatus.Conn. Set ExecFn to script command responses;

// uploads are captured in Files; every call is recorded.

//

// ExecFn must honor the Conn.Exec contract: a command that "runs" returns a

// nil error even on a non-zero exit, with the status in ExecResult.ExitCode —

// matching the real SSH transport. Returning a non-nil error models a failure

// to run at all (no session, IO error), NOT a non-zero exit code.

type FakeConn struct {

	ExecFn func(ctx context.Context, cmd legatus.Cmd) (legatus.ExecResult, error)

	// StreamFn, when set, backs ExecStream instead of the ExecFn+copy default — for

	// fakes that must write to the sinks incrementally or honor ctx mid-stream.

	StreamFn func(ctx context.Context, cmd legatus.Cmd, stdout, stderr io.Writer) (legatus.ExecResult, error)

	Files    map[string][]byte

	mu     sync.Mutex

	Execs  []legatus.Cmd

	Gets   []string

	Puts   []PutCall

	closed bool

}

// PutCall records one Put: the destination, mode, and resolved options — so a

// test can assert sudo/owner threading, which the Files map alone can't show.

type PutCall struct {

	Remote string

	Mode   legatus.FileMode

	Opts   legatus.PutOptions

}

// NewFakeConn returns a ready FakeConn.

func NewFakeConn() *FakeConn { return &FakeConn{Files: map[string][]byte{}} }

// Exec records the command and delegates to ExecFn (zero result if unset).

func (c *FakeConn) Exec(ctx context.Context, cmd legatus.Cmd) (legatus.ExecResult, error) {

	c.mu.Lock()

	c.Execs = append(c.Execs, cmd)

	fn := c.ExecFn

	c.mu.Unlock()

	if fn != nil {

		return fn(ctx, cmd)

	}

	return legatus.ExecResult{}, nil

}

// ExecStream records the command and streams output. When StreamFn is set it

// backs the call directly; otherwise it runs ExecFn and copies the scripted

// ExecResult.Stdout/Stderr to each non-nil writer (a nil writer keeps its bytes

// in the result), mirroring the real transports' contract.

func (c *FakeConn) ExecStream(ctx context.Context, cmd legatus.Cmd, stdout, stderr io.Writer) (legatus.ExecResult, error) {

	c.mu.Lock()

	c.Execs = append(c.Execs, cmd)

	sfn, fn := c.StreamFn, c.ExecFn

	c.mu.Unlock()

	if sfn != nil {

		return sfn(ctx, cmd, stdout, stderr)

	}

	var res legatus.ExecResult

	var err error

	if fn != nil {

		res, err = fn(ctx, cmd)

	}

	if err != nil {

		return res, err

	}

	if stdout != nil && len(res.Stdout) > 0 {

		if _, werr := stdout.Write(res.Stdout); werr != nil {

			return res, werr

		}

		res.Stdout = nil

	}

	if stderr != nil && len(res.Stderr) > 0 {

		if _, werr := stderr.Write(res.Stderr); werr != nil {

			return res, werr

		}

		res.Stderr = nil

	}

	return res, nil

}

// Put captures the uploaded content keyed by remote path, and records the call

// (mode + resolved options) in Puts.

func (c *FakeConn) Put(_ context.Context, content io.Reader, remote string, mode legatus.FileMode, opts ...legatus.PutOption) error {

	b, err := io.ReadAll(content)

	if err != nil {

		return err

	}

	var o legatus.PutOptions

	for _, opt := range opts {

		opt(&o)

	}

	c.mu.Lock()

	if c.Files == nil {

		c.Files = map[string][]byte{}

	}

	c.Files[remote] = b

	c.Puts = append(c.Puts, PutCall{Remote: remote, Mode: mode, Opts: o})

	c.mu.Unlock()

	return nil

}

// Get writes previously-Put content for remote, if any.

func (c *FakeConn) Get(_ context.Context, remote string, w io.Writer) error {

	c.mu.Lock()

	c.Gets = append(c.Gets, remote)

	b, ok := c.Files[remote]

	c.mu.Unlock()

	if ok {

		_, err := w.Write(b)

		return err

	}

	return nil

}

// Close marks the connection closed.

func (c *FakeConn) Close() error {

	c.mu.Lock()

	c.closed = true

	c.mu.Unlock()

	return nil

}

// Closed reports whether Close was called.

func (c *FakeConn) Closed() bool {

	c.mu.Lock()

	defer c.mu.Unlock()

	return c.closed

}

// FakeDialer hands out FakeConns. Conns maps host name to a specific conn;

// otherwise Default (if set) builds one, else a fresh FakeConn is returned. Dial

// is safe for concurrent use (the Runner dials hosts in parallel).

type FakeDialer struct {

	Conns   map[string]*FakeConn

	Default func(*legatus.Host) *FakeConn

	mu    sync.Mutex

	Dials []string

}

// Dial records the host and returns its conn.

func (d *FakeDialer) Dial(_ context.Context, h *legatus.Host) (legatus.Conn, error) {

	d.mu.Lock()

	d.Dials = append(d.Dials, h.Name)

	c, ok := d.Conns[h.Name]

	def := d.Default

	d.mu.Unlock()

	if ok {

		return c, nil

	}

	if def != nil {

		return def(h), nil

	}

	return NewFakeConn(), nil

}