test: adding integration suite

go.mod

@@ -7,9 +7,12 @@ require (
 	github.com/go-logr/logr v0.4.0
 	github.com/go-openapi/swag v0.19.15 // indirect
 	github.com/mcuadros/go-defaults v1.2.0
+	github.com/onsi/ginkgo/v2 v2.3.1
+	github.com/onsi/gomega v1.22.0
 	github.com/openshift/api v3.9.0+incompatible
 	github.com/prometheus/client_golang v1.12.0
 	github.com/prometheus/client_model v0.2.0
+	github.com/prometheus/common v0.32.1
 	github.com/spf13/pflag v1.0.5
 	github.com/spf13/viper v1.9.0
 	go.uber.org/multierr v1.6.0

integration/deployment_test.go

@@ -0,0 +1,193 @@
+package integration
+
+import (
+	"context"
+	"errors"
+	"os/exec"
+
+	internaltesting "github.com/app-sre/deployment-validation-operator/internal/testing"
+	io_prometheus_client "github.com/prometheus/client_model/go"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/gexec"
+	appsv1 "k8s.io/api/apps/v1"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+var ErrNilMetric = errors.New("nil metric")
+
+var _ = Describe("deployments", func() {
+	var (
+		ctx          context.Context
+		cancel       context.CancelFunc
+		namespace    string
+		namespaceGen = nameGenerator("deployment-test-namespace")
+	)
+
+	prom := internaltesting.NewPromClient()
+
+	BeforeEach(func() {
+		ctx, cancel = context.WithCancel(context.Background())
+
+		namespace = namespaceGen()
+
+		By("Starting manager")
+
+		manager := exec.Command(_binPath,
+			"--kubeconfig", _kubeConfigPath,
+		)
+
+		manager.Env = []string{
+			"WATCH_NAMESPACE=" + namespace,
+		}
+
+		session, err := Start(manager, GinkgoWriter, GinkgoWriter)
+		Expect(err).ToNot(HaveOccurred())
+
+		By("Creating the watch namespace")
+
+		ns := newNamespace(namespace)
+
+		_client.Create(ctx, &ns)
+
+		rbac, err := getRBAC(namespace, managerGroup)
+		Expect(err).ToNot(HaveOccurred())
+
+		for _, obj := range rbac {
+			_client.Create(ctx, obj)
+		}
+
+		DeferCleanup(func() {
+			cancel()
+
+			By("Stopping the managers")
+
+			session.Interrupt()
+
+			if usingExistingCluster() {
+				By("Deleting watch namspace")
+
+				_client.Delete(ctx, &ns)
+			}
+		})
+	})
+
+	When("created with missing resource requirements", func() {
+		It("should generate metrics", func() {
+			_client.Create(ctx, newDeployment("test", namespace))
+
+			var (
+				deploymentMemReqMetric *io_prometheus_client.Metric
+				deploymentCPUReqMetric *io_prometheus_client.Metric
+			)
+
+			Eventually(func() error {
+				metrics, err := prom.GetDVOMetrics(ctx, "http://localhost:8383/metrics")
+				if err != nil {
+					return err
+				}
+
+				memReqMetrics := metrics["unset_memory_requirements"]
+				deploymentMemReqMetric = searchableMetrics(
+					memReqMetrics,
+				).FindDVOMetric("Deployment", "test", namespace)
+				if deploymentMemReqMetric == nil {
+					return ErrNilMetric
+				}
+
+				cpuReqMetrics := metrics["unset_cpu_requirements"]
+				deploymentCPUReqMetric = searchableMetrics(
+					cpuReqMetrics,
+				).FindDVOMetric("Deployment", "test", namespace)
+				if deploymentCPUReqMetric == nil {
+					return ErrNilMetric
+				}
+
+				return nil
+			}, "10s").Should(Succeed())
+
+			Expect(deploymentMemReqMetric.Gauge.GetValue()).To(Equal(float64(1)))
+			Expect(deploymentCPUReqMetric.Gauge.GetValue()).To(Equal(float64(1)))
+		})
+	})
+
+})
+
+func newNamespace(name string) corev1.Namespace {
+	return corev1.Namespace{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: name,
+		},
+	}
+}
+
+func newDeployment(name, namespace string) *appsv1.Deployment {
+	return &appsv1.Deployment{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      name,
+			Namespace: namespace,
+			Labels: map[string]string{
+				"app": "test",
+			},
+		},
+		Spec: appsv1.DeploymentSpec{
+			Replicas: int32Ptr(1),
+			Selector: &metav1.LabelSelector{
+				MatchLabels: map[string]string{
+					"app": "test",
+				},
+			},
+			Template: corev1.PodTemplateSpec{
+				ObjectMeta: metav1.ObjectMeta{
+					Labels: map[string]string{
+						"app": "test",
+					},
+				},
+				Spec: corev1.PodSpec{
+					Containers: []corev1.Container{
+						{
+							Name:  "test",
+							Image: "test",
+						},
+					},
+				},
+			},
+		},
+	}
+}
+
+func int32Ptr(i int32) *int32 { return &i }
+
+type searchableMetrics []*io_prometheus_client.Metric
+
+func (ms searchableMetrics) FindDVOMetric(kind, name, namespace string) *io_prometheus_client.Metric {
+	for _, m := range ms {
+		labels := searchableLables(m.GetLabel())
+
+		if labels.Contains("kind", kind) &&
+			labels.Contains("name", name) &&
+			labels.Contains("namespace", namespace) {
+			return m
+		}
+	}
+
+	return nil
+}
+
+type searchableLables []*io_prometheus_client.LabelPair
+
+func (ls searchableLables) Contains(name, val string) bool {
+	for _, l := range ls {
+		if l.GetName() != name {
+			continue
+		}
+
+		if l.GetValue() == val {
+			return true
+		}
+	}
+
+	return false
+}

integration/helpers.go

@@ -0,0 +1,121 @@
+package integration
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+
+	internaltesting "github.com/app-sre/deployment-validation-operator/internal/testing"
+
+	rbacv1 "k8s.io/api/rbac/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+)
+
+func nameGenerator(pfx string) func() string {
+	i := 0
+
+	return func() string {
+		name := fmt.Sprintf("%s-%d", pfx, i)
+
+		i++
+
+		return name
+	}
+}
+
+func getClusterRBAC(group string) ([]client.Object, error) {
+	root, err := projectRoot()
+	if err != nil {
+		return nil, err
+	}
+
+	path := filepath.Join(root, "deploy", "openshift", "cluster-role.yaml")
+
+	role, err := internaltesting.LoadUnstructuredFromFile(path)
+	if err != nil {
+		return nil, fmt.Errorf("loading role: %w", err)
+	}
+
+	return []client.Object{
+		role,
+		&rbacv1.ClusterRoleBinding{
+			ObjectMeta: metav1.ObjectMeta{
+				Name: role.GetName(),
+			},
+			Subjects: []rbacv1.Subject{
+				{
+					Kind: "Group",
+					Name: group,
+				},
+			},
+			RoleRef: rbacv1.RoleRef{
+				Kind: "ClusterRole",
+				Name: role.GetName(),
+			},
+		},
+	}, nil
+}
+
+func getRBAC(namespace, group string) ([]client.Object, error) {
+	root, err := projectRoot()
+	if err != nil {
+		return nil, err
+	}
+
+	role, err := internaltesting.LoadUnstructuredFromFile(filepath.Join(root, "deploy", "openshift", "role.yaml"))
+	if err != nil {
+		return nil, fmt.Errorf("loading role: %w", err)
+	}
+
+	role.SetNamespace(namespace)
+
+	return []client.Object{
+		role,
+		&rbacv1.RoleBinding{
+			ObjectMeta: metav1.ObjectMeta{
+				Name:      role.GetName(),
+				Namespace: namespace,
+			},
+			Subjects: []rbacv1.Subject{
+				{
+					Kind: "Group",
+					Name: group,
+				},
+			},
+			RoleRef: rbacv1.RoleRef{
+				Kind: "Role",
+				Name: role.GetName(),
+			},
+		},
+	}, nil
+}
+
+func projectRoot() (string, error) {
+	var buf bytes.Buffer
+
+	cmd := exec.Command("git", "rev-parse", "--show-toplevel")
+	cmd.Stdout = &buf
+	cmd.Stderr = io.Discard
+
+	if err := cmd.Run(); err != nil {
+		return "", fmt.Errorf("determining top level directory from git: %w", errSetup)
+	}
+
+	return strings.TrimSpace(buf.String()), nil
+}
+
+var errSetup = errors.New("test setup failed")
+
+func remove(path string) error {
+	if _, err := os.Stat(path); err != nil && os.IsNotExist(err) {
+		return nil
+	}
+
+	return os.Remove(path)
+}