rollout

type ContainerImage struct {
	Name  string // the container's own name field
	Init  bool   // an initContainer
	Image string
}

type DeploymentStatus struct {
	Namespace, Name string
	Images          []ContainerImage
	// Complete reports whether the rollout has finished, by kubectl's own four-condition test
	// (deploymentRolloutComplete). DeadlineExceeded is the one condition kubectl treats as a
	// hard failure rather than "still rolling out" — the Deployment's own progressDeadlineSeconds
	// has been exceeded — and is reported here rather than as a Go error, since it is a fact
	// about cluster state, not a call failure.
	Complete         bool
	DeadlineExceeded bool
	// Detail is a short, kubectl-style human-readable line: what's still pending, or why the
	// deadline was exceeded, or that the rollout finished.
	Detail string
	// RestartedAt is the pod template's RestartAnnotation value, "" when it has never been
	// restarted this way. Read so a restart can say what it supersedes, and so a caller can
	// tell its own stamp from someone else's.
	RestartedAt string
	// The fields below describe whether a restart of this Deployment can actually be graceful.
	// They are read here because the read that fetches them is already being made; hoist warns
	// on them and never blocks (AGENTS.md principle 5), since "roll it anyway" is a legitimate
	// thing to want and the operator is the one who knows.
	//
	// Replicas is spec.replicas (1 when unset, matching Kubernetes' own default). Strategy is
	// spec.strategy.type ("RollingUpdate" when unset). MaxUnavailable and MaxSurge are that
	// strategy's own values already RESOLVED against Replicas by Kubernetes' own rules —
	// percentages round down for unavailable and up for surge — because the raw 25%/25%
	// defaults say nothing on their own: at one replica they resolve to 0 and 1, which is
	// precisely the case where a naive "one replica means downtime" claim is wrong.
	// ReadinessProbes counts containers that declare one.
	Replicas        int32
	Strategy        string
	MaxUnavailable  int32
	MaxSurge        int32
	ReadinessProbes int
}

type Fake struct {
	Deployments map[depKey]DeploymentStatus
	JobLikes    map[jobKey]JobLikeStatus
	// DeploymentErr and JobLikeErr, when set, are returned by every call to the matching
	// method instead of the configured/zero-value behavior.
	DeploymentErr, JobLikeErr, RestartErr error
	// Strict makes an unknown Deployment return ErrNotFound, as the real client does, instead
	// of a zero-value status. Opt-in rather than the default because most tests here configure
	// only the Deployments they care about and rely on the zero value for the rest — but a test
	// about ABSENCE cannot use a fake that reports everything as present, and shipping code that
	// distinguishes the two deserves a fake that can too.
	Strict bool
	// OnRestart, when set, runs on every successful Restart — how a test models what the real
	// API server does next (the pods actually rolling), since the fake has no controller.
	OnRestart func(namespace, name string, at time.Time)
	// RestartLandsDespiteErr models the one outcome a patch cannot report: the API server
	// committed the write and the response was lost. With it set alongside RestartErr, the
	// stamp is recorded AND the error returned — which is the only way to exercise a caller's
	// did-it-actually-land recovery. Without it, RestartErr means the write did not happen.
	RestartLandsDespiteErr bool

	Calls []string
	// contains filtered or unexported fields
}

type JobLikeStatus struct {
	Namespace, Name, Kind string // Kind is "Job" or "CronJob"
	Detail                string
}

type Rollout interface {
	// Deployment reads namespace/name's current images and rollout completeness.
	Deployment(ctx context.Context, namespace, name string) (DeploymentStatus, error)
	// JobLike reads namespace/name's current state, for kind "Job" or "CronJob".
	JobLike(ctx context.Context, namespace, name, kind string) (JobLikeStatus, error)
	// Restart rolls namespace/name's pods without changing what it runs, by stamping the pod
	// template's restart annotation — exactly what `kubectl rollout restart` does. It is the
	// ONE write in this package; everything else here reads (see the package doc, and
	// pkg/argo.Refresh, which holds the same position there).
	Restart(ctx context.Context, namespace, name string, at time.Time) error
}