internal/controllers/monitoring/monitoring_test.go - master - githubmirror/ydb-kubernetes-operator

internal/controllers/monitoring/monitoring_test.go
245 строк6 KB
Egor Tarasov
Add GRPC Service port configuration (#301)
20 май 2025, 13:13
20 май 2025, 13:13b8ad65c
package monitoring_test

import (
	"context"
	"fmt"
	"path/filepath"
	"testing"

	. "github.com/onsi/ginkgo/v2"
	. "github.com/onsi/gomega"
	monitoringv1 "github.com/prometheus-operator/prometheus-operator/pkg/apis/monitoring/v1"
	corev1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/types"
	"sigs.k8s.io/controller-runtime/pkg/client"
	"sigs.k8s.io/controller-runtime/pkg/manager"

	api "github.com/ydb-platform/ydb-kubernetes-operator/api/v1alpha1"
	. "github.com/ydb-platform/ydb-kubernetes-operator/internal/controllers/constants" //nolint:revive,stylecheck
	"github.com/ydb-platform/ydb-kubernetes-operator/internal/controllers/monitoring"
	"github.com/ydb-platform/ydb-kubernetes-operator/internal/labels"
	"github.com/ydb-platform/ydb-kubernetes-operator/internal/test"
	testobjects "github.com/ydb-platform/ydb-kubernetes-operator/tests/test-k8s-objects"
)

var (
	k8sClient client.Client
	ctx       context.Context
)

func TestMonitoringApis(t *testing.T) {
	RegisterFailHandler(Fail)

	test.SetupK8STestManager(&ctx, &k8sClient, func(mgr *manager.Manager) []test.Reconciler {
		return []test.Reconciler{
			&monitoring.DatabaseMonitoringReconciler{
				Client: k8sClient,
				Scheme: (*mgr).GetScheme(),
			},
			&monitoring.StorageMonitoringReconciler{
				Client: k8sClient,
				Scheme: (*mgr).GetScheme(),
			},
		}
	})
	BeforeEach(func() {
		nsName := testobjects.YdbNamespace

		found := corev1.Namespace{}

		err := k8sClient.Get(ctx, types.NamespacedName{Name: nsName}, &found)
		if err != nil {
			By(fmt.Sprintf("Create %s namespace", nsName))

			// FIXME: check only not found error ?
			namespace := corev1.Namespace{
				ObjectMeta: metav1.ObjectMeta{
					Name: nsName,
				},
			}
			Expect(k8sClient.Create(ctx, &namespace)).Should(Succeed())
		}
	})
	RunSpecs(t, "Monitoring controllers tests")
}

func createMockSvc(name string, parentKind string, parent client.Object) {
	GinkgoHelper()

	svc := &corev1.Service{
		ObjectMeta: metav1.ObjectMeta{
			Name:      name,
			Namespace: testobjects.YdbNamespace,
			Labels:    map[string]string{labels.ServiceComponent: "status"},
		},
		Spec: corev1.ServiceSpec{
			Ports: []corev1.ServicePort{
				{
					Name: "status",
					Port: 8765,
				},
			},
		},
	}
	Expect(k8sClient.Create(ctx, svc)).Should(Succeed())

	trueVal := true
	ref := []metav1.OwnerReference{
		{
			Kind:       parentKind,
			Name:       parent.GetName(),
			APIVersion: "v1",
			UID:        parent.GetUID(),
		},
		{
			Kind:       "Service",
			Name:       svc.Name,
			APIVersion: "v1",
			UID:        svc.GetUID(),
			Controller: &trueVal,
		},
	}
	svc.SetOwnerReferences(ref)
	Expect(k8sClient.Update(ctx, svc)).Should(Succeed())
}

func createMockDBAndSvc() {
	GinkgoHelper()

	createMockStorageAndSvc()

	db := testobjects.DefaultDatabase()
	Expect(k8sClient.Create(ctx, db)).Should(Succeed())

	db.Status.State = DatabaseReady
	Expect(k8sClient.Status().Update(ctx, db)).Should(Succeed())

	createMockSvc("database-svc-status", "Database", db)
}

func createMockStorageAndSvc() {
	GinkgoHelper()

	stor := testobjects.DefaultStorage(filepath.Join("..", "..", "..", "tests", "data", "storage-mirror-3-dc-config.yaml"))
	Expect(k8sClient.Create(ctx, stor)).Should(Succeed())

	stor.Status.State = StorageReady
	Expect(k8sClient.Status().Update(ctx, stor)).Should(Succeed())

	createMockSvc("storage-svc-status", "Storage", stor)
}

func cleanupMockStorageAndSvc() {
	storage := api.Storage{}
	Expect(k8sClient.Get(ctx, types.NamespacedName{
		Name:      testobjects.StorageName,
		Namespace: testobjects.YdbNamespace,
	}, &storage))
	Expect(k8sClient.Delete(ctx, &storage)).Should(Succeed())

	svc := corev1.Service{}
	Expect(k8sClient.Get(ctx, types.NamespacedName{
		Name:      "storage-svc-status",
		Namespace: testobjects.YdbNamespace,
	}, &svc))
	Expect(k8sClient.Delete(ctx, &svc)).Should(Succeed())
}

func cleanupMockDatabaseAndSvc() {
	cleanupMockStorageAndSvc()

	database := api.Database{}
	Expect(k8sClient.Get(ctx, types.NamespacedName{
		Name:      testobjects.DatabaseName,
		Namespace: testobjects.YdbNamespace,
	}, &database))
	Expect(k8sClient.Delete(ctx, &database)).Should(Succeed())

	svc := corev1.Service{}
	Expect(k8sClient.Get(ctx, types.NamespacedName{
		Name:      "database-svc-status",
		Namespace: testobjects.YdbNamespace,
	}, &svc))
	Expect(k8sClient.Delete(ctx, &svc)).Should(Succeed())
}

var _ = Describe("Create DatabaseMonitoring", func() {
	When("Database is already ready", func() {
		It("We must create ServiceMonitor", func() {
			createMockDBAndSvc()

			dbMon := api.DatabaseMonitoring{
				ObjectMeta: metav1.ObjectMeta{
					Name:      "database-monitoring",
					Namespace: testobjects.YdbNamespace,
				},
				Spec: api.DatabaseMonitoringSpec{
					DatabaseClusterRef: api.NamespacedRef{
						Name:      testobjects.DatabaseName,
						Namespace: testobjects.YdbNamespace,
					},
				},
			}

			Expect(k8sClient.Create(ctx, &dbMon)).Should(Succeed())

			Eventually(func() bool {
				found := monitoringv1.ServiceMonitorList{}

				Expect(k8sClient.List(ctx, &found, client.InNamespace(
					testobjects.YdbNamespace,
				))).Should(Succeed())

				for _, smon := range found.Items {
					if smon.Name == dbMon.GetName() {
						return true
					}
				}
				return false
			}, test.Timeout, test.Interval).Should(BeTrue())

			cleanupMockDatabaseAndSvc()
		})
	})
})

var _ = Describe("StorageMonitoring tests", func() {
	When("Storage is already ready", func() {
		It("We must create ServiceMonitor", func() {
			createMockStorageAndSvc()

			dbMon := api.StorageMonitoring{
				ObjectMeta: metav1.ObjectMeta{
					Name:      "storage-monitoring",
					Namespace: testobjects.YdbNamespace,
				},
				Spec: api.StorageMonitoringSpec{
					StorageRef: api.NamespacedRef{
						Name:      testobjects.StorageName,
						Namespace: testobjects.YdbNamespace,
					},
				},
			}

			Expect(k8sClient.Create(ctx, &dbMon)).Should(Succeed())

			Eventually(func() bool {
				found := monitoringv1.ServiceMonitorList{}

				Expect(k8sClient.List(ctx, &found, client.InNamespace(
					testobjects.YdbNamespace,
				))).Should(Succeed())

				for _, smon := range found.Items {
					if smon.Name == dbMon.GetName() {
						return true
					}
				}
				return false
			}, test.Timeout, test.Interval).Should(BeTrue())

			cleanupMockStorageAndSvc()
		})
	})
})