From be4fb1c942c141e50e689d8245191423f24a73b2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Patryk=20Ma=C5=82ek?= Date: Tue, 14 Dec 2021 11:31:00 +0100 Subject: [PATCH] test(tracing): add integration test for enabled tracing --- tests/integration/helm_traces_enabled_test.go | 202 ++++++++++++++++++ .../values/values_helm_traces_enabled.yaml | 44 ++++ 2 files changed, 246 insertions(+) create mode 100644 tests/integration/helm_traces_enabled_test.go create mode 100644 tests/integration/values/values_helm_traces_enabled.yaml diff --git a/tests/integration/helm_traces_enabled_test.go b/tests/integration/helm_traces_enabled_test.go new file mode 100644 index 0000000000..316d596cf5 --- /dev/null +++ b/tests/integration/helm_traces_enabled_test.go @@ -0,0 +1,202 @@ +package integration + +import ( + "context" + "fmt" + "testing" + "time" + + appsv1 "k8s.io/api/apps/v1" + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "sigs.k8s.io/e2e-framework/klient/k8s/resources" + "sigs.k8s.io/e2e-framework/klient/wait" + "sigs.k8s.io/e2e-framework/klient/wait/conditions" + "sigs.k8s.io/e2e-framework/pkg/envconf" + "sigs.k8s.io/e2e-framework/pkg/features" + + "github.com/gruntwork-io/terratest/modules/k8s" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + "github.com/SumoLogic/sumologic-kubernetes-collection/tests/integration/internal/ctxopts" + "github.com/SumoLogic/sumologic-kubernetes-collection/tests/integration/internal/stepfuncs" + "github.com/SumoLogic/sumologic-kubernetes-collection/tests/integration/internal/strings" +) + +func Test_Helm_Traces_Enabled(t *testing.T) { + const ( + tickDuration = time.Second + waitDuration = time.Minute * 2 + ) + + // TODO: + // Refactor this: we should find a way to inject this into step func helpers + // like stepfuncs.WaitUntilPodsAvailable() instead of relying on an implementation + // detail. + releaseName := strings.ReleaseNameFromT(t) + + featInstall := features.New("installation"). + Assess("sumologic secret is created", + func(ctx context.Context, t *testing.T, envConf *envconf.Config) context.Context { + k8s.WaitUntilSecretAvailable(t, ctxopts.KubectlOptions(ctx), "sumologic", 60, tickDuration) + secret := k8s.GetSecret(t, ctxopts.KubectlOptions(ctx), "sumologic") + require.Len(t, secret.Data, 10) + return ctx + }). + Assess("fluentd logs pods are available", + stepfuncs.WaitUntilPodsAvailable( + metav1.ListOptions{ + LabelSelector: fmt.Sprintf("app=%s-sumologic-fluentd-logs", releaseName), + }, + 3, + waitDuration, + tickDuration, + ), + ). + Assess("fluentd logs buffers PVCs are created", + func(ctx context.Context, t *testing.T, envConf *envconf.Config) context.Context { + namespace := ctxopts.Namespace(ctx) + releaseName := ctxopts.HelmRelease(ctx) + kubectlOptions := ctxopts.KubectlOptions(ctx) + + t.Logf("kubeconfig: %s", kubectlOptions.ConfigPath) + cl, err := k8s.GetKubernetesClientFromOptionsE(t, kubectlOptions) + require.NoError(t, err) + + assert.Eventually(t, func() bool { + pvcs, err := cl.CoreV1().PersistentVolumeClaims(namespace). + List(ctx, metav1.ListOptions{ + LabelSelector: fmt.Sprintf("app=%s-sumologic-fluentd-logs", releaseName), + }) + if !assert.NoError(t, err) { + return false + } + + return err == nil && len(pvcs.Items) == 3 + }, waitDuration, tickDuration) + return ctx + }). + Assess("fluentd metrics pods are available", + stepfuncs.WaitUntilPodsAvailable( + metav1.ListOptions{ + LabelSelector: fmt.Sprintf("app=%s-sumologic-fluentd-metrics", releaseName), + }, + 3, + waitDuration, + tickDuration, + ), + ). + Assess("fluentd metrics buffers PVCs are created", + func(ctx context.Context, t *testing.T, envConf *envconf.Config) context.Context { + namespace := ctxopts.Namespace(ctx) + releaseName := ctxopts.HelmRelease(ctx) + kubectlOptions := ctxopts.KubectlOptions(ctx) + + t.Logf("kubeconfig: %s", kubectlOptions.ConfigPath) + cl, err := k8s.GetKubernetesClientFromOptionsE(t, kubectlOptions) + require.NoError(t, err) + + assert.Eventually(t, func() bool { + pvcs, err := cl.CoreV1().PersistentVolumeClaims(namespace). + List(ctx, metav1.ListOptions{ + LabelSelector: fmt.Sprintf("app=%s-sumologic-fluentd-metrics", releaseName), + }) + if !assert.NoError(t, err) { + return false + } + + return err == nil && len(pvcs.Items) == 3 + }, waitDuration, tickDuration) + return ctx + }). + Assess("fluentd events pods are available", + stepfuncs.WaitUntilPodsAvailable( + metav1.ListOptions{ + LabelSelector: fmt.Sprintf("app=%s-sumologic-fluentd-events", releaseName), + }, + 1, + waitDuration, + tickDuration, + ), + ). + Assess("fluentd events buffers PVCs are created", + func(ctx context.Context, t *testing.T, envConf *envconf.Config) context.Context { + namespace := ctxopts.Namespace(ctx) + releaseName := ctxopts.HelmRelease(ctx) + kubectlOptions := ctxopts.KubectlOptions(ctx) + + t.Logf("kubeconfig: %s", kubectlOptions.ConfigPath) + cl, err := k8s.GetKubernetesClientFromOptionsE(t, kubectlOptions) + require.NoError(t, err) + + assert.Eventually(t, func() bool { + pvcs, err := cl.CoreV1().PersistentVolumeClaims(namespace). + List(ctx, metav1.ListOptions{ + LabelSelector: fmt.Sprintf("app=%s-sumologic-fluentd-events", releaseName), + }) + if !assert.NoError(t, err) { + return false + } + + return err == nil && len(pvcs.Items) == 1 + }, waitDuration, tickDuration) + return ctx + }). + Assess("prometheus pods are available", + stepfuncs.WaitUntilPodsAvailable( + metav1.ListOptions{ + LabelSelector: "app=prometheus", + }, + 1, + waitDuration, + tickDuration, + ), + ). + Assess("fluent-bit daemonset is running", + func(ctx context.Context, t *testing.T, envConf *envconf.Config) context.Context { + var daemonsets []appsv1.DaemonSet + require.Eventually(t, func() bool { + daemonsets = k8s.ListDaemonSets(t, ctxopts.KubectlOptions(ctx), metav1.ListOptions{ + LabelSelector: "app.kubernetes.io/name=fluent-bit", + }) + + return len(daemonsets) == 1 + }, waitDuration, tickDuration) + + require.EqualValues(t, 0, daemonsets[0].Status.NumberUnavailable) + return ctx + }). + Feature() + + featTraces := features.New("traces"). + Assess("otelcol deployment is ready", func(ctx context.Context, t *testing.T, envConf *envconf.Config) context.Context { + res := envConf.Client().Resources(ctxopts.Namespace(ctx)) + labelSelector := fmt.Sprintf("app=%s-sumologic-otelcol", releaseName) + ds := appsv1.DeploymentList{} + + require.NoError(t, + wait.For( + conditions.New(res). + ResourceListN(&ds, 1, + resources.WithLabelSelector(labelSelector), + ), + wait.WithTimeout(waitDuration), + wait.WithInterval(tickDuration), + ), + ) + require.NoError(t, + wait.For( + conditions.New(res). + DeploymentConditionMatch(&ds.Items[0], appsv1.DeploymentAvailable, corev1.ConditionTrue), + wait.WithTimeout(waitDuration), + wait.WithInterval(tickDuration), + ), + ) + return ctx + }). + Assess("wait", stepfuncs.Wait()). + Feature() + + testenv.Test(t, featInstall, featTraces) +} diff --git a/tests/integration/values/values_helm_traces_enabled.yaml b/tests/integration/values/values_helm_traces_enabled.yaml new file mode 100644 index 0000000000..d6f6dafe7f --- /dev/null +++ b/tests/integration/values/values_helm_traces_enabled.yaml @@ -0,0 +1,44 @@ +sumologic: + setupEnabled: true + accessId: "dummy" + accessKey: "dummy" + endpoint: http://receiver-mock.receiver-mock:3000/terraform/api/ + + traces: + enabled: true + +# Prevent snowball effect by filtering out receiver mock logs +fluent-bit: + config: + filters: | + [FILTER] + Name grep + Match containers.var.log.containers.receiver-mock* + Exclude log .* + +# Request less resources so that this fits on Github actions runners environment +kube-prometheus-stack: + prometheus: + prometheusSpec: + resources: + requests: + cpu: 100m + memory: 128Mi + +# Request less resources so that this fits on Github actions runners environment +metadata: + persistence: + size: 128Mi + + logs: + statefulset: + resources: + requests: + cpu: 100m + memory: 128Mi + metrics: + statefulset: + resources: + requests: + cpu: 100m + memory: 128Mi