chore(test): update CRD tags and test new service password funcs

Author: dmolik

Makefile

@@ -33,7 +33,7 @@ CONTAINER_TOOL ?= docker
 SHELL = /usr/bin/env bash -o pipefail
 .SHELLFLAGS = -ec
 
-K8S_VERSION ?= 1.32.1
+K8S_VERSION ?= 1.32.2
 ENVTEST_K8S_VERSION = $(K8S_VERSION)
 CILIUM_VERSION ?= 1.16.5
 VALKEY_VERSION ?= 8.0.2

api/v1/valkey_types.go

@@ -45,113 +45,134 @@ type ValkeySpec struct {
 
 	// Turn on an init container to set permissions on the persistent volume
 	// +kubebuilder:default:=false
-	VolumePermissions bool `json:"volumePermissions,omitempty"`
+	VolumePermissions bool `json:"volumePermissions"`
 
 	// TLS Support
 	// +kubebuilder:default:=false
+	// +optional
 	TLS bool `json:"tls,omitempty"`
 	// Certificate Issuer
+	// +optional
 	CertIssuer string `json:"certIssuer,omitempty"`
 	// Certificate Issuer Type
 	// +kubebuilder:default:="ClusterIssuer"
 	// +kubebuilder:validation:Enum=ClusterIssuer;Issuer
+	// +optional
 	CertIssuerType string `json:"certIssuerType,omitempty"`
 
 	// Enable prometheus
 	// +kubebuilder:default:=false
-	Prometheus bool `json:"prometheus,omitempty"`
+	Prometheus bool `json:"prometheus"`
 	// Extra prometheus labels for operator targeting
+	// +optional
 	PrometheusLabels map[string]string `json:"prometheusLabels,omitempty"`
 
 	// Cluster Domain - used for DNS
 	// +kubebuilder:default:=cluster.local
-	ClusterDomain string `json:"clusterDomain,omitempty"`
+	ClusterDomain string `json:"clusterDomain"`
 
 	// Persistent volume claim
+	// +optional
 	Storage *corev1.PersistentVolumeClaim `json:"storage,omitempty"`
 
 	// Resources requirements and limits for the Valkey Server container
+	// +optional
 	Resources *corev1.ResourceRequirements `json:"resources,omitempty"`
 
 	// External access configuration
+	// +optional
 	ExternalAccess *ExternalAccess `json:"externalAccess,omitempty"`
 
 	// Anonymous Auth
 	// +kubebuilder:default:=false
-	AnonymousAuth bool `json:"anonymousAuth,omitempty"`
+	AnonymousAuth bool `json:"anonymousAuth"`
 
 	// Service Password
+	// +optional
 	ServicePassword *corev1.SecretKeySelector `json:"servicePassword,omitempty"`
 
 	// Tolerations
+	// +optional
 	Tolerations []corev1.Toleration `json:"tolerations,omitempty"`
 
 	// Node Selector
+	// +optional
 	NodeSelector map[string]string `json:"nodeSelector,omitempty"`
 
 	// Which endpoint is shown as the preferred endpoint valid values are 'ip', 'hostname', or 'unknown-endpoint'.
 	// +kubebuilder:default:="ip"
 	// +kubebuilder:validation:Enum=ip;hostname;unknown-endpoint
+	// +optional
 	ClusterPreferredEndpointType string `json:"clusterPreferredEndpointType,omitempty"`
 }
 
 // ExternalAccess defines the external access configuration
 type ExternalAccess struct {
 	// Enable external access
 	// +kubebuilder:default:=false
-	Enabled bool `json:"enabled,omitempty"`
+	Enabled bool `json:"enabled"`
 
 	// External access type
 	// LoadBalancer or Proxy, the LoadBalancer type will create a LoadBalancer service for each Valkey Shard (master node)
 	// The Proxy type will create a single LoadBalancer service and use an envoy proxy to route traffic to the Valkey Shards
 	// +kubebuilder:default:=Proxy
 	// +kubebuilder:validation:Enum=LoadBalancer;Proxy
-	Type string `json:"type,omitempty"`
+	Type string `json:"type"`
 
 	// Proxy Settings
+	// +optional
 	Proxy *ProxySettings `json:"proxy,omitempty"`
 
 	// LoadBalancer Settings
 	LoadBalancer *LoadBalancerSettings `json:"loadBalancer,omitempty"`
 
 	// Cert Issuer for external access TLS certificate
+	// +optional
 	CertIssuer string `json:"certIssuer,omitempty"`
 
 	// Cert Issuer Type for external access TLS certificate
 	// +kubebuilder:default:="ClusterIssuer"
 	// +kubebuilder:validation:Enum=ClusterIssuer;Issuer
+	// +optional
 	CertIssuerType string `json:"certIssuerType,omitempty"`
 
 	// Support External DNS
 	// +kubebuilder:default:=false
+	// +optional
 	ExternalDNS bool `json:"externalDNS,omitempty"`
 }
 
 // ProxySettings defines the proxy settings
 type ProxySettings struct {
 	// Image to use for the proxy
 	// +kubebuilder:default:="envoyproxy/envoy:v1.32.1"
+	// +optional
 	Image string `json:"image,omitempty"`
 	// Resources requirements and limits for the proxy container
+	// +optional
 	Resources *corev1.ResourceRequirements `json:"resources,omitempty"`
 
 	// Extra Envoy configuration
+	// +optional
 	ExtraConfig string `json:"extraConfig,omitempty"`
 
 	// Annotations for the proxy service
+	// +optional
 	Annotations map[string]string `json:"annotations,omitempty"`
 
 	// Replicas for the proxy
 	// +kubebuilder:default:=1
-	Replicas *int32 `json:"replicas,omitempty"`
+	Replicas *int32 `json:"replicas"`
 
 	// External Hostname for the proxy
+	// +optional
 	Hostname string `json:"hostname,omitempty"`
 }
 
 // LoadBalancerSettings defines the load balancer settings
 type LoadBalancerSettings struct {
 	// Annotations for the load balancer service
+	// +optional
 	Annotations map[string]string `json:"annotations,omitempty"`
 }
 

config/crd/bases/hyperspike.io_valkeys.yaml

@@ -205,6 +205,8 @@ spec:
                               More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
                             type: object
                         type: object
+                    required:
+                    - replicas
                     type: object
                   type:
                     default: Proxy
@@ -216,6 +218,9 @@ spec:
                     - LoadBalancer
                     - Proxy
                     type: string
+                required:
+                - enabled
+                - type
                 type: object
               image:
                 description: Image to use
@@ -780,6 +785,11 @@ spec:
                 description: Turn on an init container to set permissions on the persistent
                   volume
                 type: boolean
+            required:
+            - anonymousAuth
+            - clusterDomain
+            - prometheus
+            - volumePermissions
             type: object
           status:
             description: ValkeyStatus defines the observed state of Valkey

config/manager/kustomization.yaml

@@ -5,4 +5,4 @@ kind: Kustomization
 images:
 - name: controller
   newName: localhost:5000/valkey-operator
-  newTag: "3"
+  newTag: "1"

internal/controller/valkey_controller_utils_test.go

@@ -20,6 +20,7 @@ import (
 	"testing"
 
 	hyperspikeiov1 "hyperspike.io/valkey-operator/api/v1"
+	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
@@ -45,3 +46,62 @@ func TestLabels(t *testing.T) {
 		t.Errorf("Expected %v, got %v", "test-resource", result["app.kubernetes.io/instance"])
 	}
 }
+
+func TestAnnotations(t *testing.T) {
+	testAnnotations := map[string]string{
+		"app": "valkey",
+	}
+	valkey := &hyperspikeiov1.Valkey{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:        "test-resource",
+			Namespace:   "default",
+			Annotations: testAnnotations,
+		},
+	}
+	result := annotations(valkey)
+	if testAnnotations["app"] != result["app"] {
+		t.Errorf("Expected %v, got %v", testAnnotations["app"], result["app"])
+	}
+}
+
+func TestServicePasswordKey(t *testing.T) {
+	valkey := &hyperspikeiov1.Valkey{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "test-resource",
+			Namespace: "default",
+		},
+	}
+	result := getServicePasswordKey(valkey)
+	if result != "password" {
+		t.Errorf("Expected %v, got %v", "test-resource", result)
+	}
+	valkey.Spec.ServicePassword = &corev1.SecretKeySelector{
+		Key: "test-password",
+	}
+	result = getServicePasswordKey(valkey)
+	if result != "test-password" {
+		t.Errorf("Expected %v, got %v", "test-password", result)
+	}
+}
+
+func TestServicePasswordName(t *testing.T) {
+	valkey := &hyperspikeiov1.Valkey{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "test-resource",
+			Namespace: "default",
+		},
+	}
+	result := getServicePasswordName(valkey)
+	if result != "test-resource" {
+		t.Errorf("Expected %v, got %v", "test-resource", result)
+	}
+	valkey.Spec.ServicePassword = &corev1.SecretKeySelector{
+		LocalObjectReference: corev1.LocalObjectReference{
+			Name: "test-password",
+		},
+	}
+	result = getServicePasswordName(valkey)
+	if result != "test-password" {
+		t.Errorf("Expected %v, got %v", "test-password", result)
+	}
+}