Project: Dapr (App Definition and Development / Application Definition & Image Build)
File: writing-e2e-test.md

Before writing e2e test, make sure that you have and can run the e2e tests. In order to add new e2e test, you need to implement test app and test driver: Test app*: A simple http server listening to 3000 port exposes the test entry endpoints(`/tests/{test}`) to call dapr runtime APIs. Test driver code will deploy to Kubernetes cluster with dapr sidecar. Test driver*: A Go test with `e2e` build tag deploys test app to Kubernetes cluster and runs go tests by calling the test entry endpoints of test app. A test app is in and can be shared by the multiple test drivers. Technically, it can be written in any languages, but Go is recommended to keep the code base consistent and simple. is the good example of test app as a boilerplate code. Create new test app directory under . Copy `app.go`, `Dockerfile`, and `service.yaml` from to test app directory app.go : A simple http server written in Go Dockerfile : Dockerfile for test app service.yaml : Test app deployment yaml for kubectl. This is for development purpose but not used by the actual e2e test. Modify `app.go` Run go app and validate the http endpoints of app.go Add your test app name to `E2ETESTAPPS` variable in Build test image via make ```bash make build-e2e-app-[new app directory name] make push-e2e-app-[new app directory name] ``` Update `service.yaml` properly - change the metadata and registry/imagename Deploy app to your k8s cluster for testing purpose ```bash kubectl apply -f service.yaml ``` Get external ip for the app ```bash kubectl get svc ``` Validate the external endpoint using wget/curl/postman Delete test app ```bash kubectl delete -f service.yaml ``` A test driver is a typical Go test with `e2e` build tag under . It can deploy test apps to a test cluster, run the tests, and clean up all test apps and any resources. We provides test runner framework to manage the test app's lifecycle during the test so that you do not need to manage the test apps by yourself. We plan to add more functionalities to test runner later, such as the log collection of test app POD. Note: Any test app you deploy should have a name unique to your test driver. Multiple test drivers may be run at the same time by the automated E2E test runner, so if you have an app name which is not unique, you may collide with another test

Also, make sure that any stateful resources (pubsub topics, statestores, secrets, etc.) have names unique to your test driver. Create new test directory under . Create go test file based on the below example: `// +build e2e` must be placed at the first line of test code `TestMain(m testing.M)` defines the list of test apps and component, which will be used in `TestXxx(t testing.T)` Define new package for the test Use Go test best practice ```go // +build e2e package hellodapr_e2e import ( "testing" kube "github.com/dapr/dapr/tests/platforms/kubernetes" "github.com/dapr/dapr/tests/runner" "github.com/stretchr/testify/require" ... ) // Test runner instance var tr *runner.TestRunner // Go test main entry - https://golang.org/pkg/testing/#hdr-Main func TestMain(m *testing.M) { testApps := []kube.AppDescription{ { AppName: "hellodapr", DaprEnabled: true, ImageName: "e2e-hellodapr", Replicas: 1, IngressEnabled: true, MetricsEnabled: true, }, } tr = runner.NewTestRunner("hellodapr", testApps, nil, nil) os.Exit(tr.Start(m)) } func TestHelloDapr(t *testing.T) { externalURL := tr.Platform.AcquireAppExternalURL("hellodapr") require.NotEmpty(t, externalURL, "external URL must not be empty") // Call endpoint for "hellodapr" test app resp, err := httpGet(externalURL) require.NoError(t, err) ... } func TestStateStore(t *testing.T) { ... } ``` Define the test apps in `TestMain()` and create test runner instance ```go // The array of test apps which will be used for the entire tests // defined in this test driver file testApps := []kube.AppDescription{ { AppName: "hellodapr", // app name DaprEnabled: true, // dapr sidecar injection ImageName: "e2e-hellodapr", // docker image name 'e2e-[test app name]' Replicas: 1, // number of replicas IngressEnabled: true, // enable ingress endpoint MetricsEnabled: true, // enable metrics endpoint }, } // Create test runner instance with 'hellodapr' runner id tr = runner.NewTestRunner("hellodapr", testApps, nil, nil) // Start the test os.Exit(tr.Start(m)) ``` Write the test by implementing `TestXxx(t *testing.T)` methods Acquire app external url to call test app endpoint Send http request to test app endpoint ```go func TestHelloDapr(t *testing.T) { // Acquire app external url externalURL := tr.Platform.AcquireAppExternalURL("hellodapr") require.NotEmpty(t, externalURL, "external URL must not be empty") // Call endpoint for "hellodapr" test app resp, err := httpGet(externalURL) require.NoError(t, err) ... } ``` If you use minikube for your dev environment, set `DAPRTESTMINIKUBE_IP` environment variable to IP address from `minikube ip` Debug Go test Using . For example, if you want to debug `TestHelloDapr` test, ```bash dlv test --build-flags='-tags=e2e' ./tests/e2e/... -- -test.run ^TestHelloDapr$ ``` Using VSCode + Go plugin (recommended) provides the good debugging experience. However, it does not provide a way to add build tag to build option so you need to remove `// +build e2e` build constraints in your go test and temporarily during debugging. Run all e2e tests ```bash make test-e2e-all ```