refactor(telegram): rewrite tests using netemx (#1183)

This diff rewrites telegram tests using netemx. This is part of
ooni/probe#2461.

---------

Co-authored-by: kelmenhorst <[email protected]>

Author: 2 people

internal/experiment/telegram/telegram_test.go

@@ -4,13 +4,21 @@ import (
 	"context"
 	"fmt"
 	"io"
+	"net"
+	"net/http"
+	"sync"
 	"testing"
 
+	"github.com/apex/log"
+	"github.com/google/gopacket/layers"
+	"github.com/ooni/netem"
 	"github.com/ooni/probe-cli/v3/internal/experiment/telegram"
 	"github.com/ooni/probe-cli/v3/internal/experiment/urlgetter"
-	"github.com/ooni/probe-cli/v3/internal/legacy/mockable"
+	"github.com/ooni/probe-cli/v3/internal/mocks"
 	"github.com/ooni/probe-cli/v3/internal/model"
+	"github.com/ooni/probe-cli/v3/internal/netemx"
 	"github.com/ooni/probe-cli/v3/internal/netxlite"
+	"github.com/ooni/probe-cli/v3/internal/runtimex"
 )
 
 func TestNewExperimentMeasurer(t *testing.T) {
@@ -23,66 +31,6 @@ func TestNewExperimentMeasurer(t *testing.T) {
 	}
 }
 
-func TestGood(t *testing.T) {
-	measurer := telegram.NewExperimentMeasurer(telegram.Config{})
-	measurement := new(model.Measurement)
-	args := &model.ExperimentArgs{
-		Callbacks:   model.NewPrinterCallbacks(model.DiscardLogger),
-		Measurement: measurement,
-		Session: &mockable.Session{
-			MockableLogger: model.DiscardLogger,
-		},
-	}
-	err := measurer.Run(context.Background(), args)
-	if err != nil {
-		t.Fatal(err)
-	}
-	tk := measurement.TestKeys.(*telegram.TestKeys)
-	if tk.Agent != "redirect" {
-		t.Fatal("unexpected Agent")
-	}
-	if tk.FailedOperation != nil {
-		t.Fatal("unexpected FailedOperation")
-	}
-	if tk.Failure != nil {
-		t.Fatal("unexpected Failure")
-	}
-	if len(tk.NetworkEvents) <= 0 {
-		t.Fatal("no NetworkEvents?!")
-	}
-	if len(tk.Queries) <= 0 {
-		t.Fatal("no Queries?!")
-	}
-	if len(tk.Requests) <= 0 {
-		t.Fatal("no Requests?!")
-	}
-	if len(tk.TCPConnect) <= 0 {
-		t.Fatal("no TCPConnect?!")
-	}
-	if len(tk.TLSHandshakes) <= 0 {
-		t.Fatal("no TLSHandshakes?!")
-	}
-	if tk.TelegramHTTPBlocking != false {
-		t.Fatal("unexpected TelegramHTTPBlocking")
-	}
-	if tk.TelegramTCPBlocking != false {
-		t.Fatal("unexpected TelegramTCPBlocking")
-	}
-	if tk.TelegramWebFailure != nil {
-		t.Fatal("unexpected TelegramWebFailure")
-	}
-	if tk.TelegramWebStatus != "ok" {
-		t.Fatal("unexpected TelegramWebStatus")
-	}
-	sk, err := measurer.GetSummaryKeys(measurement)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, ok := sk.(telegram.SummaryKeys); !ok {
-		t.Fatal("invalid type for summary keys")
-	}
-}
-
 func TestUpdateWithNoAccessPointsBlocking(t *testing.T) {
 	tk := telegram.NewTestKeys()
 	tk.Update(urlgetter.MultiOutput{
@@ -317,3 +265,302 @@ func TestSummaryKeysWorksAsIntended(t *testing.T) {
 		})
 	}
 }
+
+// telegramWebAddr is the web.telegram.org IP address as of 2023-07-11
+const telegramWebAddr = "149.154.167.99"
+
+// configureDNSWithAddr configures the given DNS config for web.telegram.org using the given addr.
+func configureDNSWithAddr(config *netem.DNSConfig, addr string) {
+	config.AddRecord("web.telegram.org", "web.telegram.org", addr)
+}
+
+// configureDNSWithDefaults configures the given DNS config for web.telegram.org using the default addr.
+func configureDNSWithDefaults(config *netem.DNSConfig) {
+	configureDNSWithAddr(config, telegramWebAddr)
+}
+
+// telegramHTTPServerNetStackHandler is a [netemx.QAEnvNetStackHandler] that serves HTTP requests
+// on the given addr and ports 443 and 80 as required by the telegram nettest
+type telegramHTTPServerNetStackHandler struct {
+	closers []io.Closer
+	mu      sync.Mutex
+}
+
+var _ netemx.QAEnvNetStackHandler = &telegramHTTPServerNetStackHandler{}
+
+// Close implements netemx.QAEnvNetStackHandler.
+func (nsh *telegramHTTPServerNetStackHandler) Close() error {
+	// make the method locked as requested by the documentation
+	defer nsh.mu.Unlock()
+	nsh.mu.Lock()
+
+	// close each of the closers
+	for _, closer := range nsh.closers {
+		_ = closer.Close()
+	}
+
+	// be idempotent
+	nsh.closers = []io.Closer{}
+	return nil
+}
+
+// Listen implements netemx.QAEnvNetStackHandler.
+func (nsh *telegramHTTPServerNetStackHandler) Listen(stack *netem.UNetStack) error {
+	// make the method locked as requested by the documentation
+	defer nsh.mu.Unlock()
+	nsh.mu.Lock()
+
+	// we create an empty mux, which should cause a 404 for each webpage, which seems what
+	// the servers used by telegram DC do as of 2023-07-11
+	mux := http.NewServeMux()
+
+	// listen on port 80
+	nsh.listenPort(stack, mux, 80)
+
+	// listen on port 443
+	nsh.listenPort(stack, mux, 443)
+	return nil
+}
+
+func (nsh *telegramHTTPServerNetStackHandler) listenPort(stack *netem.UNetStack, mux *http.ServeMux, port uint16) {
+	// create the listening address
+	ipAddr := net.ParseIP(stack.IPAddress())
+	runtimex.Assert(ipAddr != nil, "expected valid IP address")
+	addr := &net.TCPAddr{IP: ipAddr, Port: int(port)}
+	listener := runtimex.Try1(stack.ListenTCP("tcp", addr))
+	srvr := &http.Server{Handler: mux}
+
+	// serve requests in a background goroutine
+	go srvr.Serve(listener)
+
+	// make sure we track the server (the .Serve method will close the
+	// listener once we close the server itself)
+	nsh.closers = append(nsh.closers, srvr)
+}
+
+// newQAEnvironment creates a QA environment for testing using the given addresses.
+func newQAEnvironment(ipaddrs ...string) *netemx.QAEnv {
+	// create a single handler for handling all the requests
+	handler := &telegramHTTPServerNetStackHandler{
+		closers: []io.Closer{},
+		mu:      sync.Mutex{},
+	}
+
+	// create the options for constructing the env
+	var options []netemx.QAEnvOption
+	for _, ipaddr := range ipaddrs {
+		options = append(options, netemx.QAEnvOptionNetStack(ipaddr, handler))
+	}
+
+	// add explicit logging which helps to inspect the tests results
+	options = append(options, netemx.QAEnvOptionLogger(log.Log))
+
+	// add handler for telegram web (we're using a different-from-reality HTTP handler
+	// but we're not testing for the returned webpage, so we should be fine)
+	options = append(options, netemx.QAEnvOptionHTTPServer(telegramWebAddr, netemx.QAEnvDefaultHTTPHandler()))
+
+	// create the environment proper with all the options
+	env := netemx.NewQAEnv(options...)
+
+	// register with all the possible resolvers the correct DNS records - registering again
+	// inside individual tests will override the values we're setting here
+	configureDNSWithDefaults(env.ISPResolverConfig())
+	configureDNSWithDefaults(env.OtherResolversConfig())
+	return env
+}
+
+func TestMeasurerRun(t *testing.T) {
+	t.Run("without DPI: expect success", func(t *testing.T) {
+		// create a new test environment
+		env := newQAEnvironment(telegram.DatacenterIPAddrs...)
+		defer env.Close()
+
+		env.Do(func() {
+			measurer := telegram.NewExperimentMeasurer(telegram.Config{})
+			measurement := &model.Measurement{}
+			args := &model.ExperimentArgs{
+				Callbacks:   model.NewPrinterCallbacks(log.Log),
+				Measurement: measurement,
+				Session:     &mocks.Session{MockLogger: func() model.Logger { return log.Log }},
+			}
+			err := measurer.Run(context.Background(), args)
+			if err != nil {
+				t.Fatalf("Unexpected error: %s", err)
+			}
+			tk, _ := (measurement.TestKeys).(*telegram.TestKeys)
+			if tk.TelegramWebFailure != nil {
+				t.Fatalf("Unexpected Telegram Web failure %s", *tk.TelegramWebFailure)
+			}
+			if tk.TelegramHTTPBlocking {
+				t.Fatalf("Unexpected HTTP blocking")
+			}
+			if tk.TelegramTCPBlocking {
+				t.Fatal("Unexpected TCP blocking")
+			}
+			if tk.Agent != "redirect" {
+				t.Fatal("unexpected Agent")
+			}
+			if tk.FailedOperation != nil {
+				t.Fatal("unexpected FailedOperation")
+			}
+			if tk.Failure != nil {
+				t.Fatal("unexpected Failure")
+			}
+			if len(tk.NetworkEvents) <= 0 {
+				t.Fatal("no NetworkEvents?!")
+			}
+			if len(tk.Queries) <= 0 {
+				t.Fatal("no Queries?!")
+			}
+			if len(tk.Requests) <= 0 {
+				t.Fatal("no Requests?!")
+			}
+			if len(tk.TCPConnect) <= 0 {
+				t.Fatal("no TCPConnect?!")
+			}
+			if len(tk.TLSHandshakes) <= 0 {
+				t.Fatal("no TLSHandshakes?!")
+			}
+			if tk.TelegramWebStatus != "ok" {
+				t.Fatal("unexpected TelegramWebStatus")
+			}
+			sk, err := measurer.GetSummaryKeys(measurement)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, ok := sk.(telegram.SummaryKeys); !ok {
+				t.Fatal("invalid type for summary keys")
+			}
+		})
+	})
+
+	t.Run("with poisoned DNS: expect TelegramWebFailure", func(t *testing.T) {
+		// create a new test environment
+		env := newQAEnvironment(telegram.DatacenterIPAddrs...)
+		defer env.Close()
+
+		// register bogon entries for web.telegram.org in the resolver's ISP
+		env.ISPResolverConfig().AddRecord("web.telegram.org", "web.telegram.org", "10.10.34.35")
+
+		env.Do(func() {
+			measurer := telegram.NewExperimentMeasurer(telegram.Config{})
+			measurement := &model.Measurement{}
+			args := &model.ExperimentArgs{
+				Callbacks:   model.NewPrinterCallbacks(log.Log),
+				Measurement: measurement,
+				Session:     &mocks.Session{MockLogger: func() model.Logger { return log.Log }},
+			}
+			err := measurer.Run(context.Background(), args)
+			if err != nil {
+				t.Fatalf("Unexpected error: %s", err)
+			}
+			tk, _ := (measurement.TestKeys).(*telegram.TestKeys)
+			if tk.TelegramWebFailure == nil {
+				t.Fatalf("Expected Web Failure but got none")
+			}
+			if tk.TelegramHTTPBlocking {
+				t.Fatal("Unexpected HTTP blocking")
+			}
+			if tk.TelegramTCPBlocking {
+				t.Fatal("Unexpected TCP blocking")
+			}
+		})
+	})
+
+	t.Run("with DPI that drops TCP traffic towards telegram endpoint: expect Telegram(HTTP|TCP)Blocking", func(t *testing.T) {
+		if testing.Short() {
+			t.Skip("skip test in short mode")
+		}
+
+		// overwrite global Datacenters, otherwise the test times out because there are too many endpoints
+		orig := telegram.DatacenterIPAddrs
+		telegram.DatacenterIPAddrs = []string{
+			"149.154.175.50",
+		}
+		defer func() {
+			telegram.DatacenterIPAddrs = orig
+		}()
+
+		// create a new test environment
+		env := newQAEnvironment(telegram.DatacenterIPAddrs...)
+		defer env.Close()
+
+		// add DPI engine to emulate the censorship condition
+		dpi := env.DPIEngine()
+		for _, dc := range telegram.DatacenterIPAddrs {
+			dpi.AddRule(&netem.DPIDropTrafficForServerEndpoint{
+				Logger:          log.Log,
+				ServerIPAddress: dc,
+				ServerPort:      80,
+				ServerProtocol:  layers.IPProtocolTCP,
+			})
+			dpi.AddRule(&netem.DPIDropTrafficForServerEndpoint{
+				Logger:          log.Log,
+				ServerIPAddress: dc,
+				ServerPort:      443,
+				ServerProtocol:  layers.IPProtocolTCP,
+			})
+		}
+
+		env.Do(func() {
+			measurer := telegram.NewExperimentMeasurer(telegram.Config{})
+			measurement := &model.Measurement{}
+			args := &model.ExperimentArgs{
+				Callbacks:   model.NewPrinterCallbacks(log.Log),
+				Measurement: measurement,
+				Session:     &mocks.Session{MockLogger: func() model.Logger { return log.Log }},
+			}
+			err := measurer.Run(context.Background(), args)
+			if err != nil {
+				t.Fatalf("Unexpected error: %s", err)
+			}
+			tk, _ := (measurement.TestKeys).(*telegram.TestKeys)
+			if tk.TelegramWebFailure != nil {
+				t.Fatalf("Unexpected Telegram Web failure %s", *tk.TelegramWebFailure)
+			}
+			if !tk.TelegramHTTPBlocking {
+				t.Fatal("Expected HTTP blocking but got none")
+			}
+			if !tk.TelegramTCPBlocking {
+				t.Fatal("Expected TCP blocking but got none")
+			}
+		})
+	})
+
+	t.Run("with DPI that drops TLS traffic with SNI = web.telegram.org: expect TelegramWebFailure", func(t *testing.T) {
+		// create a new test environment
+		env := newQAEnvironment(telegram.DatacenterIPAddrs...)
+		defer env.Close()
+
+		// add DPI engine to emulate the censorship condition
+		dpi := env.DPIEngine()
+		dpi.AddRule(&netem.DPIResetTrafficForTLSSNI{
+			Logger: log.Log,
+			SNI:    "web.telegram.org",
+		})
+
+		env.Do(func() {
+			measurer := telegram.NewExperimentMeasurer(telegram.Config{})
+			measurement := &model.Measurement{}
+			args := &model.ExperimentArgs{
+				Callbacks:   model.NewPrinterCallbacks(log.Log),
+				Measurement: measurement,
+				Session:     &mocks.Session{MockLogger: func() model.Logger { return log.Log }},
+			}
+			err := measurer.Run(context.Background(), args)
+			if err != nil {
+				t.Fatalf("Unexpected error: %s", err)
+			}
+			tk, _ := (measurement.TestKeys).(*telegram.TestKeys)
+			if tk.TelegramWebFailure == nil {
+				t.Fatalf("Expected Web Failure but got none")
+			}
+			if tk.TelegramHTTPBlocking {
+				t.Fatal("Unexpected HTTP blocking")
+			}
+			if tk.TelegramTCPBlocking {
+				t.Fatal("Unexpected TCP blocking")
+			}
+		})
+	})
+}