Add new-e2e example test for NewDDAWithOperator

test/new-e2e/examples/kind_local_operator_test.go

@@ -0,0 +1,118 @@
+// Unless explicitly stated otherwise all files in this repository are licensed
+// under the Apache License Version 2.0.
+// This product includes software developed at Datadog (https://www.datadoghq.com/).
+// Copyright 2016-present Datadog, Inc.
+
+package examples
+
+import (
+	"context"
+	"github.com/DataDog/test-infra-definitions/components/datadog/agent"
+	"github.com/DataDog/test-infra-definitions/components/datadog/agentwithoperatorparams"
+	fakeintakeComp "github.com/DataDog/test-infra-definitions/components/datadog/fakeintake"
+	"github.com/DataDog/test-infra-definitions/components/datadog/operatorparams"
+	compkube "github.com/DataDog/test-infra-definitions/components/kubernetes"
+	"github.com/DataDog/test-infra-definitions/resources/local"
+	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+
+	"github.com/DataDog/datadog-agent/test/new-e2e/pkg/e2e"
+	"github.com/DataDog/datadog-agent/test/new-e2e/pkg/environments"
+	"github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes"
+)
+
+const namespace = "e2e-operator"
+
+type localKindOperatorSuite struct {
+	e2e.BaseSuite[environments.Kubernetes]
+}
+
+func localKindOperatorProvisioner() e2e.PulumiEnvRunFunc[environments.Kubernetes] {
+	return func(ctx *pulumi.Context, env *environments.Kubernetes) error {
+		kindEnv, err := local.NewEnvironment(ctx)
+		if err != nil {
+			return err
+		}
+
+		kindCluster, err := compkube.NewLocalKindCluster(&kindEnv, kindEnv.CommonNamer().ResourceName("kind-operator"), kindEnv.KubernetesVersion())
+		if err != nil {
+			return err
+		}
+
+		if err := kindCluster.Export(ctx, &env.KubernetesCluster.ClusterOutput); err != nil {
+			return err
+		}
+
+		// Build Kubernetes provider
+		kindKubeProvider, err := kubernetes.NewProvider(ctx, kindEnv.CommonNamer().ResourceName("k8s-provider"), &kubernetes.ProviderArgs{
+			Kubeconfig:            kindCluster.KubeConfig,
+			EnableServerSideApply: pulumi.BoolPtr(true),
+		})
+		if err != nil {
+			return err
+		}
+
+		fakeIntake, err := fakeintakeComp.NewLocalDockerFakeintake(&kindEnv, "fakeintake")
+		if err != nil {
+			return err
+		}
+		if err := fakeIntake.Export(ctx, &env.FakeIntake.FakeintakeOutput); err != nil {
+			return err
+		}
+
+		// Setup operator options
+		operatorOpts := make([]operatorparams.Option, 0)
+		operatorOpts = append(
+			operatorOpts,
+			operatorparams.WithNamespace(namespace),
+		)
+
+		customDDA := `
+spec:
+  features:
+    apm:
+      enabled: true
+`
+		// Setup DDA options
+		ddaOptions := make([]agentwithoperatorparams.Option, 0)
+		ddaOptions = append(
+			ddaOptions,
+			agentwithoperatorparams.WithNamespace(namespace),
+			agentwithoperatorparams.WithTLSKubeletVerify(false),
+			agentwithoperatorparams.WithDDAConfig(customDDA),
+		)
+
+		// Create Datadog Agent with Operator component
+		operatorAgentComponent, err := agent.NewDDAWithOperator(&kindEnv, kindEnv.CommonNamer().ResourceName("dd-operator-agent"), kindKubeProvider, operatorOpts, ddaOptions...)
+
+		if err != nil {
+			return err
+		}
+
+		if err := operatorAgentComponent.Export(ctx, &env.Agent.KubernetesAgentOutput); err != nil {
+			return err
+		}
+
+		return nil
+	}
+}
+
+func TestOperatorKindSuite(t *testing.T) {
+	e2e.Run(t, &localKindOperatorSuite{}, e2e.WithPulumiProvisioner(localKindOperatorProvisioner(), nil))
+}
+
+func (k *localKindOperatorSuite) TestClusterAgentInstalled() {
+	res, _ := k.Env().KubernetesCluster.Client().CoreV1().Pods(namespace).List(context.TODO(), v1.ListOptions{})
+	containsClusterAgent := false
+	for _, pod := range res.Items {
+		if strings.Contains(pod.Name, "cluster-agent") {
+			containsClusterAgent = true
+			break
+		}
+	}
+	assert.True(k.T(), containsClusterAgent, "Cluster Agent not found")
+}

test/new-e2e/examples/kind_operator_test.go

@@ -0,0 +1,50 @@
+// Unless explicitly stated otherwise all files in this repository are licensed
+// under the Apache License Version 2.0.
+// This product includes software developed at Datadog (https://www.datadoghq.com/).
+// Copyright 2016-present Datadog, Inc.
+
+package examples
+
+import (
+	"context"
+	awskubernetes "github.com/DataDog/datadog-agent/test/new-e2e/pkg/environments/aws/kubernetes"
+	"github.com/DataDog/test-infra-definitions/components/datadog/agentwithoperatorparams"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"strings"
+	"testing"
+
+	"github.com/DataDog/datadog-agent/test/new-e2e/pkg/e2e"
+	"github.com/DataDog/datadog-agent/test/new-e2e/pkg/environments"
+	"github.com/stretchr/testify/assert"
+)
+
+type kindOperatorSuite struct {
+	e2e.BaseSuite[environments.Kubernetes]
+}
+
+func TestKindOperatorSuite(t *testing.T) {
+	customDDA := `
+spec:
+  features:
+    apm:
+      enabled: true
+`
+
+	e2e.Run(t, &kindOperatorSuite{}, e2e.WithProvisioner(awskubernetes.KindProvisioner(
+		awskubernetes.WithOperator(),
+		awskubernetes.WithOperatorDDAOptions(agentwithoperatorparams.WithDDAConfig(customDDA)),
+	)),
+	)
+}
+
+func (v *kindOperatorSuite) TestClusterAgentInstalled() {
+	res, _ := v.Env().KubernetesCluster.Client().CoreV1().Pods("datadog").List(context.TODO(), v1.ListOptions{})
+	containsClusterAgent := false
+	for _, pod := range res.Items {
+		if strings.Contains(pod.Name, "cluster-agent") {
+			containsClusterAgent = true
+			break
+		}
+	}
+	assert.True(v.T(), containsClusterAgent, "Cluster Agent not found")
+}

test/new-e2e/pkg/environments/aws/kubernetes/kind.go

@@ -9,6 +9,10 @@ package awskubernetes
 import (
 	"context"
 	"fmt"
+	"github.com/DataDog/test-infra-definitions/components/datadog/agent"
+	"github.com/DataDog/test-infra-definitions/components/datadog/agentwithoperatorparams"
+	"github.com/DataDog/test-infra-definitions/components/datadog/operator"
+	"github.com/DataDog/test-infra-definitions/components/datadog/operatorparams"
 
 	"github.com/DataDog/test-infra-definitions/common/utils"
 
@@ -88,7 +92,7 @@ func KindRunFunc(ctx *pulumi.Context, env *environments.Kubernetes, params *Prov
 		return err
 	}
 
-	kindCluster, err := kubeComp.NewKindCluster(&awsEnv, host, params.name, awsEnv.KubernetesVersion(), utils.PulumiDependsOn(installEcrCredsHelperCmd))
+	kindCluster, err := kubeComp.NewKindCluster(&awsEnv, host, awsEnv.CommonNamer().ResourceName("kind"), awsEnv.KubernetesVersion(), utils.PulumiDependsOn(installEcrCredsHelperCmd))
 	if err != nil {
 		return err
 	}
@@ -127,9 +131,10 @@ func KindRunFunc(ctx *pulumi.Context, env *environments.Kubernetes, params *Prov
 		env.FakeIntake = nil
 	}
 
+	kindClusterName := ctx.Stack()
+
 	var dependsOnCrd []pulumi.Resource
-	if params.agentOptions != nil {
-		kindClusterName := ctx.Stack()
+	if params.agentOptions != nil && !params.deployOperator {
 		helmValues := fmt.Sprintf(`
 datadog:
   kubelet:
@@ -150,6 +155,43 @@ agents:
 			return err
 		}
 		dependsOnCrd = append(dependsOnCrd, agent)
+	}
+
+	if params.deployOperator {
+		operatorOpts := make([]operatorparams.Option, 0)
+		operatorOpts = append(
+			operatorOpts,
+			params.operatorOptions...,
+		)
+
+		if params.operatorDDAOptions != nil && params.deployOperator {
+			ddaOptions := make([]agentwithoperatorparams.Option, 0)
+			ddaOptions = append(
+				ddaOptions,
+				params.operatorDDAOptions...,
+			)
+
+			ddaWithOperatorComp, err := agent.NewDDAWithOperator(&awsEnv, awsEnv.CommonNamer().ResourceName("dd-operator-agent"), kubeProvider, operatorOpts, ddaOptions...)
+
+			if err != nil {
+				return err
+			}
+
+			if err := ddaWithOperatorComp.Export(ctx, &env.Agent.KubernetesAgentOutput); err != nil {
+				return err
+			}
+			dependsOnCrd = append(dependsOnCrd, ddaWithOperatorComp)
+
+		} else {
+			operatorComp, err := operator.NewOperator(&awsEnv, kindClusterName, kubeProvider, operatorOpts...)
+			if err != nil {
+				return err
+			}
+			err = operatorComp.Export(ctx, nil)
+			if err != nil {
+				return err
+			}
+		}
 	} else {
 		env.Agent = nil
 	}

test/new-e2e/pkg/environments/aws/kubernetes/params.go

@@ -8,6 +8,8 @@ package awskubernetes
 
 import (
 	"fmt"
+	"github.com/DataDog/test-infra-definitions/components/datadog/agentwithoperatorparams"
+	"github.com/DataDog/test-infra-definitions/components/datadog/operatorparams"
 
 	"github.com/DataDog/datadog-agent/test/new-e2e/pkg/runner"
 	"github.com/DataDog/datadog-agent/test/new-e2e/pkg/utils/optional"
@@ -25,13 +27,15 @@ import (
 
 // ProvisionerParams contains all the parameters needed to create the environment
 type ProvisionerParams struct {
-	name              string
-	vmOptions         []ec2.VMOption
-	agentOptions      []kubernetesagentparams.Option
-	fakeintakeOptions []fakeintake.Option
-	eksOptions        []eks.Option
-	extraConfigParams runner.ConfigMap
-	workloadAppFuncs  []WorkloadAppFunc
+	name               string
+	vmOptions          []ec2.VMOption
+	agentOptions       []kubernetesagentparams.Option
+	fakeintakeOptions  []fakeintake.Option
+	eksOptions         []eks.Option
+	extraConfigParams  runner.ConfigMap
+	workloadAppFuncs   []WorkloadAppFunc
+	operatorOptions    []operatorparams.Option
+	operatorDDAOptions []agentwithoperatorparams.Option
 
 	eksLinuxNodeGroup        bool
 	eksLinuxARMNodeGroup     bool
@@ -40,23 +44,27 @@ type ProvisionerParams struct {
 	awsEnv                   *aws.Environment
 	deployDogstatsd          bool
 	deployTestWorkload       bool
+	deployOperator           bool
 }
 
 func newProvisionerParams() *ProvisionerParams {
 	return &ProvisionerParams{
-		name:              defaultVMName,
-		vmOptions:         []ec2.VMOption{},
-		agentOptions:      []kubernetesagentparams.Option{},
-		fakeintakeOptions: []fakeintake.Option{},
-		eksOptions:        []eks.Option{},
-		extraConfigParams: runner.ConfigMap{},
-		workloadAppFuncs:  []WorkloadAppFunc{},
+		name:               defaultVMName,
+		vmOptions:          []ec2.VMOption{},
+		agentOptions:       []kubernetesagentparams.Option{},
+		fakeintakeOptions:  []fakeintake.Option{},
+		eksOptions:         []eks.Option{},
+		extraConfigParams:  runner.ConfigMap{},
+		workloadAppFuncs:   []WorkloadAppFunc{},
+		operatorOptions:    []operatorparams.Option{},
+		operatorDDAOptions: []agentwithoperatorparams.Option{},
 
 		eksLinuxNodeGroup:        false,
 		eksLinuxARMNodeGroup:     false,
 		eksBottlerocketNodeGroup: false,
 		eksWindowsNodeGroup:      false,
 		deployDogstatsd:          false,
+		deployOperator:           false,
 	}
 }
 
@@ -171,3 +179,25 @@ func WithAwsEnv(env *aws.Environment) ProvisionerOption {
 		return nil
 	}
 }
+
+// WithOperator Deploys the Datadog Operator
+func WithOperator() ProvisionerOption {
+	return func(params *ProvisionerParams) error {
+		params.deployOperator = true
+		return nil
+	}
+}
+
+func WithOperatorOptions(opts ...operatorparams.Option) ProvisionerOption {
+	return func(params *ProvisionerParams) error {
+		params.operatorOptions = opts
+		return nil
+	}
+}
+
+func WithOperatorDDAOptions(opts ...agentwithoperatorparams.Option) ProvisionerOption {
+	return func(params *ProvisionerParams) error {
+		params.operatorDDAOptions = opts
+		return nil
+	}
+}