Files
cozystack/pkg/registry/apps/application/rest_workloads_test.go
T
Aleksei Sviridkin 99f3d3b2b7 feat(controller): tag a DataVolume cause with a condition reason
WorkloadsReady=False covers different situations: a stopped VM has
no pod and its monitor reports it not operational on purpose, while a
disk whose DataVolume never populates is broken. A consumer that wants
to react to one and not the other had only the message text to go by.

The WorkloadMonitor status gains a Reason next to Message, set to
DataVolumeNotReady by the DataVolume check, and the Application API
carries it into the WorkloadsReady condition in place of the generic
reason whenever a monitor that is not operational names one.

Assisted-by: LLM
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-10-02 14:02:33 +03:00

424 lines
12 KiB
Go

package application
import (
"context"
"testing"
cozyv1alpha1 "github.com/cozystack/cozystack/api/v1alpha1"
appsv1alpha1 "github.com/cozystack/cozystack/pkg/apis/apps/v1alpha1"
"github.com/cozystack/cozystack/pkg/config"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime"
"sigs.k8s.io/controller-runtime/pkg/client/fake"
helmv2 "github.com/fluxcd/helm-controller/api/v2"
)
func newTestRESTWithSchemes(objs ...runtime.Object) *REST {
scheme := runtime.NewScheme()
_ = cozyv1alpha1.AddToScheme(scheme)
_ = helmv2.AddToScheme(scheme)
builder := fake.NewClientBuilder().WithScheme(scheme)
for _, obj := range objs {
builder = builder.WithRuntimeObjects(obj)
}
c := builder.Build()
return NewREST(c, nil, &config.Resource{
Application: config.ApplicationConfig{
Kind: "PostgreSQL",
Plural: "postgresqls",
Singular: "postgresql",
},
Release: config.ReleaseConfig{
Prefix: "postgresql-",
},
})
}
func TestGetWorkloadsOperational_NoMonitors(t *testing.T) {
r := newTestRESTWithSchemes()
ws, err := r.getWorkloadsOperational(context.TODO(), "default", "mydb", nil)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if ws.found {
t.Error("expected found=false when no monitors exist")
}
if !ws.operational {
t.Error("expected operational=true when no monitors exist")
}
}
func TestGetWorkloadsOperational_AllOperational(t *testing.T) {
m1 := &cozyv1alpha1.WorkloadMonitor{
ObjectMeta: metav1.ObjectMeta{
Name: "mon-1",
Namespace: "default",
Labels: map[string]string{
appsv1alpha1.ApplicationKindLabel: "PostgreSQL",
appsv1alpha1.ApplicationGroupLabel: "apps.cozystack.io",
appsv1alpha1.ApplicationNameLabel: "mydb",
},
},
Status: cozyv1alpha1.WorkloadMonitorStatus{
Operational: new(true),
},
}
m2 := &cozyv1alpha1.WorkloadMonitor{
ObjectMeta: metav1.ObjectMeta{
Name: "mon-2",
Namespace: "default",
Labels: map[string]string{
appsv1alpha1.ApplicationKindLabel: "PostgreSQL",
appsv1alpha1.ApplicationGroupLabel: "apps.cozystack.io",
appsv1alpha1.ApplicationNameLabel: "mydb",
},
},
Status: cozyv1alpha1.WorkloadMonitorStatus{
Operational: new(true),
},
}
r := newTestRESTWithSchemes(m1, m2)
ws, err := r.getWorkloadsOperational(context.TODO(), "default", "mydb", nil)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if !ws.found {
t.Error("expected found=true")
}
if !ws.operational {
t.Error("expected operational=true when all monitors are operational")
}
}
func TestGetWorkloadsOperational_SomeNotOperational(t *testing.T) {
m1 := &cozyv1alpha1.WorkloadMonitor{
ObjectMeta: metav1.ObjectMeta{
Name: "mon-1",
Namespace: "default",
Labels: map[string]string{
appsv1alpha1.ApplicationKindLabel: "PostgreSQL",
appsv1alpha1.ApplicationGroupLabel: "apps.cozystack.io",
appsv1alpha1.ApplicationNameLabel: "mydb",
},
},
Status: cozyv1alpha1.WorkloadMonitorStatus{
Operational: new(true),
},
}
m2 := &cozyv1alpha1.WorkloadMonitor{
ObjectMeta: metav1.ObjectMeta{
Name: "mon-2",
Namespace: "default",
Labels: map[string]string{
appsv1alpha1.ApplicationKindLabel: "PostgreSQL",
appsv1alpha1.ApplicationGroupLabel: "apps.cozystack.io",
appsv1alpha1.ApplicationNameLabel: "mydb",
},
},
Status: cozyv1alpha1.WorkloadMonitorStatus{
Operational: new(false),
},
}
r := newTestRESTWithSchemes(m1, m2)
ws, err := r.getWorkloadsOperational(context.TODO(), "default", "mydb", nil)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if !ws.found {
t.Error("expected found=true")
}
if ws.operational {
t.Error("expected operational=false when at least one monitor is not operational")
}
}
func TestGetWorkloadsOperational_OperationalNil(t *testing.T) {
m := &cozyv1alpha1.WorkloadMonitor{
ObjectMeta: metav1.ObjectMeta{
Name: "mon-1",
Namespace: "default",
Labels: map[string]string{
appsv1alpha1.ApplicationKindLabel: "PostgreSQL",
appsv1alpha1.ApplicationGroupLabel: "apps.cozystack.io",
appsv1alpha1.ApplicationNameLabel: "mydb",
},
},
Status: cozyv1alpha1.WorkloadMonitorStatus{
Operational: nil, // Not yet reconciled
},
}
r := newTestRESTWithSchemes(m)
ws, err := r.getWorkloadsOperational(context.TODO(), "default", "mydb", nil)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if !ws.found {
t.Error("expected found=true")
}
if !ws.unknown {
t.Error("expected unknown=true when Operational is nil")
}
}
func TestGetWorkloadsOperational_MixedNilAndOperational(t *testing.T) {
m1 := &cozyv1alpha1.WorkloadMonitor{
ObjectMeta: metav1.ObjectMeta{
Name: "mon-1",
Namespace: "default",
Labels: map[string]string{
appsv1alpha1.ApplicationKindLabel: "PostgreSQL",
appsv1alpha1.ApplicationGroupLabel: "apps.cozystack.io",
appsv1alpha1.ApplicationNameLabel: "mydb",
},
},
Status: cozyv1alpha1.WorkloadMonitorStatus{
Operational: new(true),
},
}
m2 := &cozyv1alpha1.WorkloadMonitor{
ObjectMeta: metav1.ObjectMeta{
Name: "mon-2",
Namespace: "default",
Labels: map[string]string{
appsv1alpha1.ApplicationKindLabel: "PostgreSQL",
appsv1alpha1.ApplicationGroupLabel: "apps.cozystack.io",
appsv1alpha1.ApplicationNameLabel: "mydb",
},
},
Status: cozyv1alpha1.WorkloadMonitorStatus{
Operational: nil,
},
}
r := newTestRESTWithSchemes(m1, m2)
ws, err := r.getWorkloadsOperational(context.TODO(), "default", "mydb", nil)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if !ws.unknown {
t.Error("expected unknown=true when at least one monitor has nil Operational")
}
}
func TestGetWorkloadsOperational_MixedFailedAndPending(t *testing.T) {
m1 := &cozyv1alpha1.WorkloadMonitor{
ObjectMeta: metav1.ObjectMeta{
Name: "mon-1",
Namespace: "default",
Labels: map[string]string{
appsv1alpha1.ApplicationKindLabel: "PostgreSQL",
appsv1alpha1.ApplicationGroupLabel: "apps.cozystack.io",
appsv1alpha1.ApplicationNameLabel: "mydb",
},
},
Status: cozyv1alpha1.WorkloadMonitorStatus{
Operational: new(false), // Confirmed failure
},
}
m2 := &cozyv1alpha1.WorkloadMonitor{
ObjectMeta: metav1.ObjectMeta{
Name: "mon-2",
Namespace: "default",
Labels: map[string]string{
appsv1alpha1.ApplicationKindLabel: "PostgreSQL",
appsv1alpha1.ApplicationGroupLabel: "apps.cozystack.io",
appsv1alpha1.ApplicationNameLabel: "mydb",
},
},
Status: cozyv1alpha1.WorkloadMonitorStatus{
Operational: nil, // Not yet reconciled
},
}
r := newTestRESTWithSchemes(m1, m2)
ws, err := r.getWorkloadsOperational(context.TODO(), "default", "mydb", nil)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if ws.operational {
t.Error("expected operational=false when at least one monitor is explicitly failed")
}
if !ws.unknown {
t.Error("expected unknown=true when at least one monitor has nil Operational")
}
}
func TestConvertConditions_MixedFailedAndPendingShowsFalse(t *testing.T) {
mFailed := &cozyv1alpha1.WorkloadMonitor{
ObjectMeta: metav1.ObjectMeta{
Name: "mon-failed",
Namespace: "default",
Labels: map[string]string{
appsv1alpha1.ApplicationKindLabel: "PostgreSQL",
appsv1alpha1.ApplicationGroupLabel: "apps.cozystack.io",
appsv1alpha1.ApplicationNameLabel: "mydb",
},
},
Status: cozyv1alpha1.WorkloadMonitorStatus{
Operational: new(false),
},
}
mPending := &cozyv1alpha1.WorkloadMonitor{
ObjectMeta: metav1.ObjectMeta{
Name: "mon-pending",
Namespace: "default",
Labels: map[string]string{
appsv1alpha1.ApplicationKindLabel: "PostgreSQL",
appsv1alpha1.ApplicationGroupLabel: "apps.cozystack.io",
appsv1alpha1.ApplicationNameLabel: "mydb",
},
},
Status: cozyv1alpha1.WorkloadMonitorStatus{
Operational: nil,
},
}
r := newTestRESTWithSchemes(mFailed, mPending)
hr := &helmv2.HelmRelease{
ObjectMeta: metav1.ObjectMeta{
Name: "postgresql-mydb",
Namespace: "default",
Labels: map[string]string{
ApplicationKindLabel: "PostgreSQL",
ApplicationGroupLabel: "apps.cozystack.io",
ApplicationNameLabel: "mydb",
},
},
}
hr.Status.Conditions = []metav1.Condition{
{Type: "Ready", Status: metav1.ConditionTrue, Reason: "Succeeded", Message: "ok"},
}
app, err := r.convertHelmReleaseToApplication(context.TODO(), hr, nil)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
// Concrete failure should take priority over unknown
wc := findCondition(app.GetConditions(), "WorkloadsReady")
if wc == nil {
t.Fatal("expected WorkloadsReady condition")
}
if wc.Status != metav1.ConditionFalse {
t.Errorf("expected WorkloadsReady=False (failure takes priority over unknown), got %s", wc.Status)
}
}
func TestGetWorkloadsOperational_DifferentApp_NotFound(t *testing.T) {
m := &cozyv1alpha1.WorkloadMonitor{
ObjectMeta: metav1.ObjectMeta{
Name: "mon-1",
Namespace: "default",
Labels: map[string]string{
appsv1alpha1.ApplicationKindLabel: "PostgreSQL",
appsv1alpha1.ApplicationGroupLabel: "apps.cozystack.io",
appsv1alpha1.ApplicationNameLabel: "other-db",
},
},
Status: cozyv1alpha1.WorkloadMonitorStatus{
Operational: new(false),
},
}
r := newTestRESTWithSchemes(m)
ws, err := r.getWorkloadsOperational(context.TODO(), "default", "mydb", nil)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if ws.found {
t.Error("expected found=false for different app name")
}
if !ws.operational {
t.Error("expected operational=true when no matching monitors found")
}
}
func TestConvertConditions_WorkloadsReadyCarriesMonitorMessages(t *testing.T) {
monitor := func(name string, operational bool, message, reason string) *cozyv1alpha1.WorkloadMonitor {
return &cozyv1alpha1.WorkloadMonitor{
ObjectMeta: metav1.ObjectMeta{
Name: name,
Namespace: "default",
Labels: map[string]string{
appsv1alpha1.ApplicationKindLabel: "PostgreSQL",
appsv1alpha1.ApplicationGroupLabel: "apps.cozystack.io",
appsv1alpha1.ApplicationNameLabel: "mydb",
},
},
Status: cozyv1alpha1.WorkloadMonitorStatus{Operational: new(operational), Message: message, Reason: reason},
}
}
hr := &helmv2.HelmRelease{
ObjectMeta: metav1.ObjectMeta{
Name: "postgresql-mydb",
Namespace: "default",
Labels: map[string]string{
ApplicationKindLabel: "PostgreSQL",
ApplicationGroupLabel: "apps.cozystack.io",
ApplicationNameLabel: "mydb",
},
},
}
hr.Status.Conditions = []metav1.Condition{
{Type: "Ready", Status: metav1.ConditionTrue, Reason: "Succeeded", Message: "ok"},
}
cases := []struct {
name string
monitors []runtime.Object
want string
reason string
}{
{
"messages of the monitors that are not operational, sorted",
[]runtime.Object{
monitor("mon-b", false, "DataVolume b is ImportInProgress", cozyv1alpha1.WorkloadMonitorReasonDataVolumeNotReady),
monitor("mon-a", false, "DataVolume a is Failed", cozyv1alpha1.WorkloadMonitorReasonDataVolumeNotReady),
monitor("mon-c", true, "", ""),
},
"DataVolume a is Failed; DataVolume b is ImportInProgress",
cozyv1alpha1.WorkloadMonitorReasonDataVolumeNotReady,
},
{
"a named cause beside a monitor that names none",
[]runtime.Object{
monitor("mon-a", false, "", ""),
monitor("mon-b", false, "DataVolume b is Failed", cozyv1alpha1.WorkloadMonitorReasonDataVolumeNotReady),
},
"DataVolume b is Failed",
cozyv1alpha1.WorkloadMonitorReasonDataVolumeNotReady,
},
{
"generic message when no monitor names a cause",
[]runtime.Object{monitor("mon-a", false, "", "")},
"One or more workloads are not operational",
"WorkloadMonitorCheck",
},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
r := newTestRESTWithSchemes(tc.monitors...)
app, err := r.convertHelmReleaseToApplication(context.TODO(), hr, nil)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
wc := findCondition(app.GetConditions(), "WorkloadsReady")
if wc == nil || wc.Status != metav1.ConditionFalse {
t.Fatalf("WorkloadsReady = %+v, want False", wc)
}
if wc.Message != tc.want {
t.Errorf("message = %q, want %q", wc.Message, tc.want)
}
if wc.Reason != tc.reason {
t.Errorf("reason = %q, want %q", wc.Reason, tc.reason)
}
})
}
}