Add Coturn Interop. Tests

Author: adrianosela

.github/workflows/e2e.yaml

@@ -0,0 +1,24 @@
+# SPDX-FileCopyrightText: 2026 The Pion community <https://pion.ly>
+# SPDX-License-Identifier: MIT
+
+name: E2E
+on:
+  pull_request:
+    branches:
+      - master
+  push:
+    branches:
+      - master
+
+jobs:
+  e2e-test:
+    name: Test
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - name: checkout
+        uses: actions/checkout@v6
+      - name: test
+        run: |
+          docker build -t pion-turn-e2e -f e2e/Dockerfile .
+          docker run -i --rm pion-turn-e2e

e2e/Dockerfile

@@ -0,0 +1,11 @@
+# SPDX-FileCopyrightText: 2026 The Pion community <https://pion.ly>
+# SPDX-License-Identifier: MIT
+
+FROM docker.io/library/golang:1.26-trixie
+
+RUN apt-get update && apt-get install -y coturn
+
+COPY . /go/src/github.com/pion/turn
+WORKDIR /go/src/github.com/pion/turn/e2e
+
+CMD ["go", "test", "-tags=coturn", "-v", "."]

e2e/e2e.go

@@ -0,0 +1,5 @@
+// SPDX-FileCopyrightText: 2026 The Pion community <https://pion.ly>
+// SPDX-License-Identifier: MIT
+
+// Package e2e contains end to end tests for pion/turn
+package e2e

e2e/e2e_coturn_test.go

@@ -0,0 +1,278 @@
+// SPDX-FileCopyrightText: 2026 The Pion community <https://pion.ly>
+// SPDX-License-Identifier: MIT
+
+//go:build coturn && !js
+// +build coturn,!js
+
+package e2e
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"io"
+	"net"
+	"os"
+	"os/exec"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/pion/logging"
+	"github.com/pion/turn/v5"
+	"github.com/stretchr/testify/assert"
+)
+
+const (
+	coturnServerPort   = 3478
+	coturnConfigFile   = "/tmp/turnserver.conf"
+	coturnStartupDelay = 2 * time.Second
+)
+
+// serverCoturn starts a coturn TURN server
+func serverCoturn(c *comm) {
+	go func() {
+		c.serverMutex.Lock()
+		defer c.serverMutex.Unlock()
+
+		// Create coturn configuration file
+		config := fmt.Sprintf(`
+listening-port=%d
+listening-ip=127.0.0.1
+relay-ip=127.0.0.1
+external-ip=127.0.0.1
+user=%s:%s
+realm=%s
+lt-cred-mech
+fingerprint
+no-tls
+no-dtls
+log-file=stdout
+`, c.serverPort, c.username, c.password, c.realm)
+
+		configFile := fmt.Sprintf("/tmp/turnserver-%d.conf", c.serverPort)
+		if err := os.WriteFile(configFile, []byte(config), 0600); err != nil {
+			c.errChan <- err
+			return
+		}
+		defer func() {
+			_ = os.Remove(configFile)
+		}()
+
+		// Start coturn server with context
+		cmd := exec.CommandContext(c.ctx, "turnserver", "-c", configFile)
+		cmd.Stdout = io.Discard
+		cmd.Stderr = io.Discard
+
+		if err := cmd.Start(); err != nil {
+			c.errChan <- fmt.Errorf("failed to start coturn: %w (is coturn installed?)", err)
+			return
+		}
+
+		// Ensure proper cleanup
+		defer func() {
+			if cmd.Process != nil {
+				_ = cmd.Process.Kill()
+				_, _ = cmd.Process.Wait()
+			}
+		}()
+
+		// Ensure server has time to start
+		time.Sleep(coturnStartupDelay)
+
+		c.serverReady <- struct{}{}
+
+		// Wait for context cancellation or process exit
+		done := make(chan error, 1)
+		go func() {
+			done <- cmd.Wait()
+		}()
+
+		select {
+		case <-c.ctx.Done():
+			// Context cancelled, kill process
+			if cmd.Process != nil {
+				_ = cmd.Process.Kill()
+			}
+		case <-done:
+			// Process exited
+		}
+
+		c.serverDone <- nil
+		close(c.serverDone)
+	}()
+}
+
+// clientCoturn uses turnutils_uclient to test against a Pion TURN server
+func clientCoturn(c *comm) {
+	select {
+	case <-c.serverReady:
+		// OK
+	case <-time.After(time.Second * 5):
+		c.errChan <- errServerTimeout
+		return
+	}
+
+	c.clientMutex.Lock()
+	defer c.clientMutex.Unlock()
+
+	// Use turnutils_uclient to connect to the Pion server
+	// -v: verbose
+	// -u: username
+	// -w: password
+	// -r: realm
+	// -e: peer address (echo server)
+	// -n: number of messages
+	// -m: message size
+	// -W: time to run (seconds)
+	args := []string{
+		"-v",
+		"-u", c.username,
+		"-w", c.password,
+		"-r", c.realm,
+		"-n", "1",
+		"-m", "1",
+		"-W", "5",
+		fmt.Sprintf("127.0.0.1:%d", c.serverPort),
+	}
+
+	// #nosec G204
+	cmd := exec.Command("turnutils_uclient", args...)
+
+	stdout, err := cmd.StdoutPipe()
+	if err != nil {
+		c.errChan <- fmt.Errorf("failed to create stdout pipe: %w", err)
+		return
+	}
+	stderr, err := cmd.StderrPipe()
+	if err != nil {
+		c.errChan <- fmt.Errorf("failed to create stderr pipe: %w", err)
+		return
+	}
+
+	if err := cmd.Start(); err != nil {
+		c.errChan <- fmt.Errorf("failed to start turnutils_uclient: %w (is coturn installed?)", err)
+		return
+	}
+
+	// Monitor output for success indicators
+	go func() {
+		scanner := bufio.NewScanner(io.MultiReader(stdout, stderr))
+		for scanner.Scan() {
+			line := scanner.Text()
+			fmt.Println("turnutils_uclient:", line)
+			// Look for success indicators in coturn client output
+			if strings.Contains(line, "success") || strings.Contains(line, "allocate msg sent") {
+				c.messageReceived <- "success"
+			}
+		}
+	}()
+
+	_ = cmd.Wait()
+	c.clientDone <- nil
+	close(c.clientDone)
+}
+
+func TestPionCoturnE2EClientServer(t *testing.T) {
+	t.Run("CoturnServer", func(t *testing.T) {
+		// Test Pion Client -> Coturn Server
+		testPionE2ESimple(t, serverCoturn, clientPion)
+	})
+	t.Run("CoturnClient", func(t *testing.T) {
+		// Test Coturn Client (turnutils_uclient) -> Pion Server
+		testPionE2ESimple(t, serverPion, clientCoturn)
+	})
+}
+
+// TestCoturnVersion checks if coturn is installed and reports version
+func TestCoturnVersion(t *testing.T) {
+	cmd := exec.Command("turnserver", "--version")
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Skipf("coturn not installed: %v", err)
+	}
+	t.Logf("coturn version: %s", string(output))
+}
+
+// TestPionCoturnE2EAllocationLifecycle tests the full allocation lifecycle with coturn
+func TestPionCoturnE2EAllocationLifecycle(t *testing.T) {
+	t.Run("CoturnServer", func(t *testing.T) {
+		ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+		defer cancel()
+
+		serverPort := randomPort(t)
+
+		// Start coturn server
+		config := fmt.Sprintf(`
+listening-port=%d
+listening-ip=127.0.0.1
+relay-ip=127.0.0.1
+external-ip=127.0.0.1
+user=%s:%s
+realm=%s
+lt-cred-mech
+fingerprint
+no-tls
+no-dtls
+log-file=stdout
+`, serverPort, testUsername, testPassword, testRealm)
+
+		configFile := "/tmp/turnserver-lifecycle.conf"
+		err := os.WriteFile(configFile, []byte(config), 0600)
+		assert.NoError(t, err)
+		defer func() {
+			_ = os.Remove(configFile)
+		}()
+
+		// Start coturn
+		cmd := exec.CommandContext(ctx, "turnserver", "-c", configFile)
+		cmd.Stdout = io.Discard
+		cmd.Stderr = io.Discard
+		err = cmd.Start()
+		assert.NoError(t, err)
+
+		// Ensure cleanup
+		defer func() {
+			if cmd.Process != nil {
+				_ = cmd.Process.Kill()
+			}
+		}()
+
+		// Wait for server to start
+		time.Sleep(coturnStartupDelay)
+
+		// Test allocation lifecycle
+		clientConn, err := net.ListenPacket("udp4", "127.0.0.1:0")
+		assert.NoError(t, err)
+		defer func() {
+			_ = clientConn.Close()
+		}()
+
+		turnClient, err := turn.NewClient(&turn.ClientConfig{
+			TURNServerAddr: fmt.Sprintf("127.0.0.1:%d", serverPort),
+			Username:       testUsername,
+			Password:       testPassword,
+			Realm:          testRealm,
+			Conn:           clientConn,
+			LoggerFactory:  logging.NewDefaultLoggerFactory(),
+		})
+		assert.NoError(t, err)
+		defer turnClient.Close()
+
+		err = turnClient.Listen()
+		assert.NoError(t, err)
+
+		// Test allocation
+		relayConn, err := turnClient.Allocate()
+		assert.NoError(t, err)
+		assert.NotNil(t, relayConn)
+
+		relayAddr := relayConn.LocalAddr()
+		assert.NotNil(t, relayAddr)
+		t.Logf("Allocated relay address: %s", relayAddr)
+
+		// Close relay connection
+		err = relayConn.Close()
+		assert.NoError(t, err)
+	})
+}