Allow Postgres PVC expansion

Previously, any change to spec.database.size on an existing
OpenStackLightspeed instance returned ErrPostgresPVCSizeMismatch,
forcing users to delete the PVC (and lose all data) to resize storage.

Now the operator distinguishes three cases:
- Expand: patches the PVC's storage request to the larger value.
- Equal: no-op, no error.
- Shrink: returns ErrPostgresPVCSizeShrink with a clear message
  showing the current and requested sizes; the PVC is not modified.

Unit tests cover all three cases using a fake client. Kuttl tests
was considered by rejected because it requires the cluster's default
StorageClass to have allowVolumeExpansionenabled, which can not be
assumed in a portable test environment. And since kuttl also has no
proper mechanism to skip tests conditionally it would produce unreliable
results across different clusters.

Signed-off-by: Lucas Alvares Gomes <lucasagomes@gmail.com>

Author: umago

internal/controller/errors.go

@@ -67,6 +67,7 @@ var (
 	ErrGetPostgresConfigMap          = errors.New("failed to get Postgres configmap")
 	ErrCreatePostgresNetworkPolicy   = errors.New("failed to create Postgres network policy")
 	ErrCreatePostgresPVC             = errors.New("failed to create Postgres PVC")
+	ErrPatchPostgresPVC              = errors.New("failed to patch Postgres PVC")
 	ErrGetPostgresPVC                = errors.New("failed to get Postgres PVC")
-	ErrPostgresPVCSizeMismatch       = errors.New("existing Postgres PVC size does not match requested size")
+	ErrPostgresPVCSizeShrink         = errors.New("cannot shrink existing Postgres PVC")
 )

internal/controller/postgres_reconciler.go

@@ -248,13 +248,22 @@ func reconcilePostgresPVC(h *common_helper.Helper, ctx context.Context, instance
 	}
 
 	if err == nil {
-		// PVC already exists, validate if the size matches
 		existingQty := pvc.Spec.Resources.Requests[corev1.ResourceStorage]
-		if requestedQty.Cmp(existingQty) != 0 {
-			return fmt.Errorf("%w: requested size %s but existing PVC has %s",
-				ErrPostgresPVCSizeMismatch, requestedQty.String(), existingQty.String())
+		cmp := requestedQty.Cmp(existingQty)
+		if cmp < 0 {
+			return fmt.Errorf("%w: current %s, requested %s",
+				ErrPostgresPVCSizeShrink, existingQty.String(), requestedQty.String())
 		}
-		h.GetLogger().Info("Reusing the existing PostgreSQL PVC with a matching size", "name", pvc.Name)
+		if cmp == 0 {
+			h.GetLogger().Info("Reusing the existing PostgreSQL PVC with a matching size", "name", pvc.Name)
+			return nil
+		}
+		patch := client.MergeFrom(pvc.DeepCopy())
+		pvc.Spec.Resources.Requests[corev1.ResourceStorage] = requestedQty
+		if err := h.GetClient().Patch(ctx, pvc, patch); err != nil {
+			return fmt.Errorf("%w: %w", ErrPatchPostgresPVC, err)
+		}
+		h.GetLogger().Info("Postgres PVC storage request expanded", "name", pvc.Name, "from", existingQty.String(), "to", requestedQty.String())
 		return nil
 	}
 

internal/controller/postgres_reconciler_test.go

@@ -0,0 +1,161 @@
+/*
+Copyright 2026.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package controller
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"testing"
+
+	common_helper "github.com/openstack-k8s-operators/lib-common/modules/common/helper"
+	apiv1beta1 "github.com/openstack-k8s-operators/lightspeed-operator/api/v1beta1"
+	corev1 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/controller-runtime/pkg/client/fake"
+	"sigs.k8s.io/controller-runtime/pkg/client/interceptor"
+	"sigs.k8s.io/controller-runtime/pkg/log/zap"
+)
+
+func makeExistingPVC(size string) *corev1.PersistentVolumeClaim {
+	return &corev1.PersistentVolumeClaim{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      PostgresDataPVCName,
+			Namespace: "test-ns",
+		},
+		Spec: corev1.PersistentVolumeClaimSpec{
+			Resources: corev1.VolumeResourceRequirements{
+				Requests: corev1.ResourceList{
+					corev1.ResourceStorage: resource.MustParse(size),
+				},
+			},
+		},
+	}
+}
+
+func makeInstanceWithDBSize(size string) *apiv1beta1.OpenStackLightspeed {
+	return &apiv1beta1.OpenStackLightspeed{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "test-instance",
+			Namespace: "test-ns",
+		},
+		Spec: apiv1beta1.OpenStackLightspeedSpec{
+			Database: &apiv1beta1.DatabaseSpec{
+				Size: resource.MustParse(size),
+			},
+		},
+	}
+}
+
+// Expanding the PVC patches its storage request to the larger value and returns no error.
+func TestReconcilePostgresPVC_Expand(t *testing.T) {
+	h := newTestHelper(t, makeExistingPVC("1Gi"))
+	instance := makeInstanceWithDBSize("2Gi")
+
+	ctx := context.Background()
+	if err := reconcilePostgresPVC(h, ctx, instance); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	updated := &corev1.PersistentVolumeClaim{}
+	if err := h.GetClient().Get(ctx, client.ObjectKey{Name: PostgresDataPVCName, Namespace: "test-ns"}, updated); err != nil {
+		t.Fatalf("failed to get PVC after expand: %v", err)
+	}
+	got := updated.Spec.Resources.Requests[corev1.ResourceStorage]
+	want := resource.MustParse("2Gi")
+	if got.Cmp(want) != 0 {
+		t.Errorf("expected PVC storage %s after expand, got %s", want.String(), got.String())
+	}
+}
+
+// Shrinking the PVC is rejected with ErrPostgresPVCSizeShrink; the PVC is not modified.
+func TestReconcilePostgresPVC_Shrink(t *testing.T) {
+	h := newTestHelper(t, makeExistingPVC("2Gi"))
+	instance := makeInstanceWithDBSize("1Gi")
+
+	ctx := context.Background()
+	err := reconcilePostgresPVC(h, ctx, instance)
+	if err == nil {
+		t.Fatal("expected error when shrinking PVC, got nil")
+	}
+	if !errors.Is(err, ErrPostgresPVCSizeShrink) {
+		t.Errorf("expected ErrPostgresPVCSizeShrink, got %v", err)
+	}
+}
+
+// When the requested size matches the existing PVC, reconciliation is a no-op.
+func TestReconcilePostgresPVC_NoOp(t *testing.T) {
+	h := newTestHelper(t, makeExistingPVC("1Gi"))
+	instance := makeInstanceWithDBSize("1Gi")
+
+	ctx := context.Background()
+	if err := reconcilePostgresPVC(h, ctx, instance); err != nil {
+		t.Fatalf("unexpected error for matching size: %v", err)
+	}
+}
+
+func newTestHelperWithPatchErr(t *testing.T, objs ...client.Object) *common_helper.Helper {
+	t.Helper()
+
+	scheme := runtime.NewScheme()
+	if err := corev1.AddToScheme(scheme); err != nil {
+		t.Fatalf("failed to add corev1 to scheme: %v", err)
+	}
+	if err := apiv1beta1.AddToScheme(scheme); err != nil {
+		t.Fatalf("failed to add apiv1beta1 to scheme: %v", err)
+	}
+
+	patchErr := fmt.Errorf("forced patch failure")
+	fakeClient := fake.NewClientBuilder().
+		WithScheme(scheme).
+		WithObjects(objs...).
+		WithInterceptorFuncs(interceptor.Funcs{
+			Patch: func(_ context.Context, _ client.WithWatch, _ client.Object, _ client.Patch, _ ...client.PatchOption) error {
+				return patchErr
+			},
+		}).
+		Build()
+
+	instance := &apiv1beta1.OpenStackLightspeed{
+		ObjectMeta: metav1.ObjectMeta{Name: "test-instance", Namespace: "test-ns"},
+	}
+	logger := zap.New(zap.WriteTo(bytes.NewBuffer(nil)))
+	h, err := common_helper.NewHelper(instance, fakeClient, nil, scheme, logger)
+	if err != nil {
+		t.Fatalf("failed to create helper: %v", err)
+	}
+	return h
+}
+
+// If the API server rejects the patch (e.g. StorageClass lacks allowVolumeExpansion), ErrPatchPostgresPVC is returned.
+func TestReconcilePostgresPVC_PatchError(t *testing.T) {
+	h := newTestHelperWithPatchErr(t, makeExistingPVC("1Gi"))
+	instance := makeInstanceWithDBSize("2Gi")
+
+	ctx := context.Background()
+	err := reconcilePostgresPVC(h, ctx, instance)
+	if err == nil {
+		t.Fatal("expected error when patch fails, got nil")
+	}
+	if !errors.Is(err, ErrPatchPostgresPVC) {
+		t.Errorf("expected ErrPatchPostgresPVC, got %v", err)
+	}
+}