feat: start merging filtering into testingx

internal/experiment/dnsping/dnsping_test.go

@@ -99,7 +99,7 @@ func TestMeasurer_run(t *testing.T) {
 
 	t.Run("with netem: without DPI: expect success", func(t *testing.T) {
 		// create a new test environment
-		env := netemx.MustNewQAEnv(netemx.QAEnvOptionNetStack("8.8.8.8", &netemx.UDPResolverFactory{}))
+		env := netemx.MustNewQAEnv(netemx.QAEnvOptionNetStack("8.8.8.8", &netemx.DNSOverUDPServerFactory{}))
 		defer env.Close()
 
 		// we use the same configuration for all resolvers
@@ -146,7 +146,7 @@ func TestMeasurer_run(t *testing.T) {
 
 	t.Run("with netem: with DNS spoofing: expect to see delayed responses", func(t *testing.T) {
 		// create a new test environment
-		env := netemx.MustNewQAEnv(netemx.QAEnvOptionNetStack("8.8.8.8", &netemx.UDPResolverFactory{}))
+		env := netemx.MustNewQAEnv(netemx.QAEnvOptionNetStack("8.8.8.8", &netemx.DNSOverUDPServerFactory{}))
 		defer env.Close()
 
 		// we use the same configuration for all resolvers

internal/netemx/dnsoverhttps.go

@@ -14,5 +14,7 @@ var _ HTTPHandlerFactory = &DNSOverHTTPSHandlerFactory{}
 
 // NewHandler implements QAEnvHTTPHandlerFactory.
 func (f *DNSOverHTTPSHandlerFactory) NewHandler(env NetStackServerFactoryEnv, stack *netem.UNetStack) http.Handler {
-	return &testingx.DNSOverHTTPSHandler{Config: env.OtherResolversConfig()}
+	return &testingx.DNSOverHTTPSHandler{
+		RoundTripper: testingx.NewDNSRoundTripperWithDNSConfig(env.OtherResolversConfig()),
+	}
 }

internal/netemx/udpresolver.go → internal/netemx/dnsoverudp.go

@@ -11,37 +11,37 @@ import (
 	"github.com/ooni/probe-cli/v3/internal/runtimex"
 )
 
-// UDPResolverFactory implements [NetStackServerFactory] for DNS-over-UDP servers.
+// DNSOverUDPServerFactory implements [NetStackServerFactory] for DNS-over-UDP servers.
 //
 // When this factory constructs a [NetStackServer], it will use:
 //
 // 1. the [NetStackServerFactoryEnv.OtherResolversConfig] as DNS configuration;
 //
-// 2. the [NetStackServerFactoryEnv.Logger] as the logger.
+// 2. the [NetStackServerFactoryEnv.Logger] as logger.
 //
 // Use this factory along with [QAEnvOptionNetStack] to create DNS-over-UDP servers.
-type UDPResolverFactory struct{}
+type DNSOverUDPServerFactory struct{}
 
-var _ NetStackServerFactory = &UDPResolverFactory{}
+var _ NetStackServerFactory = &DNSOverUDPServerFactory{}
 
 // MustNewServer implements NetStackServerFactory.
-func (f *UDPResolverFactory) MustNewServer(env NetStackServerFactoryEnv, stack *netem.UNetStack) NetStackServer {
-	return udpResolverMustNewServer(env.OtherResolversConfig(), env.Logger(), stack)
+func (f *DNSOverUDPServerFactory) MustNewServer(env NetStackServerFactoryEnv, stack *netem.UNetStack) NetStackServer {
+	return dnsOverUDPResolverMustNewServer(env.OtherResolversConfig(), env.Logger(), stack)
 }
 
-type udpResolverFactoryForGetaddrinfo struct{}
+type dnsOverUDPServerFactoryForGetaddrinfo struct{}
 
-var _ NetStackServerFactory = &udpResolverFactoryForGetaddrinfo{}
+var _ NetStackServerFactory = &dnsOverUDPServerFactoryForGetaddrinfo{}
 
 // MustNewServer implements NetStackServerFactory.
-func (f *udpResolverFactoryForGetaddrinfo) MustNewServer(env NetStackServerFactoryEnv, stack *netem.UNetStack) NetStackServer {
-	return udpResolverMustNewServer(env.ISPResolverConfig(), env.Logger(), stack)
+func (f *dnsOverUDPServerFactoryForGetaddrinfo) MustNewServer(env NetStackServerFactoryEnv, stack *netem.UNetStack) NetStackServer {
+	return dnsOverUDPResolverMustNewServer(env.ISPResolverConfig(), env.Logger(), stack)
 }
 
-// udpResolverMustNewServer is an internal factory for creating a [NetStackServer] that
+// dnsOverUDPResolverMustNewServer is an internal factory for creating a [NetStackServer] that
 // runs a DNS-over-UDP server using the configured logger, DNS config, and stack.
-func udpResolverMustNewServer(config *netem.DNSConfig, logger model.Logger, stack *netem.UNetStack) NetStackServer {
-	return &udpResolver{
+func dnsOverUDPResolverMustNewServer(config *netem.DNSConfig, logger model.Logger, stack *netem.UNetStack) NetStackServer {
+	return &dnsOverUDPResolver{
 		closers: []io.Closer{},
 		config:  config,
 		logger:  logger,
@@ -50,7 +50,7 @@ func udpResolverMustNewServer(config *netem.DNSConfig, logger model.Logger, stac
 	}
 }
 
-type udpResolver struct {
+type dnsOverUDPResolver struct {
 	closers []io.Closer
 	config  *netem.DNSConfig
 	logger  model.Logger
@@ -59,7 +59,7 @@ type udpResolver struct {
 }
 
 // Close implements NetStackServer.
-func (srv *udpResolver) Close() error {
+func (srv *dnsOverUDPResolver) Close() error {
 	// make the method locked as requested by the documentation
 	defer srv.mu.Unlock()
 	srv.mu.Lock()
@@ -75,7 +75,7 @@ func (srv *udpResolver) Close() error {
 }
 
 // MustStart implements NetStackServer.
-func (srv *udpResolver) MustStart() {
+func (srv *dnsOverUDPResolver) MustStart() {
 	// make the method locked as requested by the documentation
 	defer srv.mu.Unlock()
 	srv.mu.Lock()

internal/netemx/udpresolver_test.go → internal/netemx/dnsoverudp_test.go

@@ -10,9 +10,9 @@ import (
 	"github.com/ooni/probe-cli/v3/internal/netxlite"
 )
 
-func TestUDPResolverFactory(t *testing.T) {
+func TestDNSOverUDPServerFactory(t *testing.T) {
 	env := MustNewQAEnv(
-		QAEnvOptionNetStack(AddressDNSGoogle8844, &UDPResolverFactory{}),
+		QAEnvOptionNetStack(AddressDNSGoogle8844, &DNSOverUDPServerFactory{}),
 	)
 	defer env.Close()
 

internal/netemx/example_test.go

@@ -20,8 +20,8 @@ import (
 // to use this QA environment in all the examples for this package.
 func exampleNewEnvironment() *netemx.QAEnv {
 	return netemx.MustNewQAEnv(
-		netemx.QAEnvOptionNetStack("8.8.4.4", &netemx.UDPResolverFactory{}),
-		netemx.QAEnvOptionNetStack("9.9.9.9", &netemx.UDPResolverFactory{}),
+		netemx.QAEnvOptionNetStack("8.8.4.4", &netemx.DNSOverUDPServerFactory{}),
+		netemx.QAEnvOptionNetStack("9.9.9.9", &netemx.DNSOverUDPServerFactory{}),
 		netemx.QAEnvOptionClientAddress(netemx.DefaultClientAddress),
 		netemx.QAEnvOptionHTTPServer(
 			netemx.AddressWwwExampleCom, netemx.ExampleWebPageHandlerFactory()),

internal/netemx/qaenv.go

@@ -182,10 +182,10 @@ func MustNewQAEnv(options ...QAEnvOption) *QAEnv {
 	}
 
 	// make sure we're going to create the ISP's DNS resolver.
-	qaEnvOptionNetStack(config.ispResolver, &udpResolverFactoryForGetaddrinfo{})(config)
+	qaEnvOptionNetStack(config.ispResolver, &dnsOverUDPServerFactoryForGetaddrinfo{})(config)
 
 	// make sure we're going to create the root DNS resolver.
-	qaEnvOptionNetStack(config.rootResolver, &UDPResolverFactory{})(config)
+	qaEnvOptionNetStack(config.rootResolver, &DNSOverUDPServerFactory{})(config)
 
 	// use a prefix logger for the QA env
 	prefixLogger := &logx.PrefixLogger{

internal/netemx/scenario.go

@@ -125,7 +125,7 @@ func MustNewScenario(config []*ScenarioDomainAddresses) *QAEnv {
 			for _, addr := range sad.Addresses {
 				opts = append(opts, QAEnvOptionNetStack(
 					addr,
-					&UDPResolverFactory{},
+					&DNSOverUDPServerFactory{},
 					&HTTPSecureServerFactory{
 						Factory:   &DNSOverHTTPSHandlerFactory{},
 						Ports:     []int{443},

internal/netxlite/dnsoverudp_test.go

@@ -12,9 +12,9 @@ import (
 	"github.com/apex/log"
 	"github.com/google/go-cmp/cmp"
 	"github.com/miekg/dns"
+	"github.com/ooni/netem"
 	"github.com/ooni/probe-cli/v3/internal/mocks"
 	"github.com/ooni/probe-cli/v3/internal/model"
-	"github.com/ooni/probe-cli/v3/internal/netxlite/filtering"
 	"github.com/ooni/probe-cli/v3/internal/testingx"
 )
 
@@ -252,18 +252,14 @@ func TestDNSOverUDPTransport(t *testing.T) {
 		})
 
 		t.Run("using a real server", func(t *testing.T) {
-			srvr := &filtering.DNSServer{
-				OnQuery: func(domain string) filtering.DNSAction {
-					return filtering.DNSActionCache
-				},
-				Cache: map[string][]string{
-					"dns.google.": {"8.8.8.8"},
-				},
-			}
-			listener, err := srvr.Start("127.0.0.1:0")
-			if err != nil {
-				t.Fatal(err)
-			}
+			udpAddr := &net.UDPAddr{
+				IP:   net.IPv4(127, 0, 0, 1),
+				Port: 0,
+			}
+			dnsConfig := netem.NewDNSConfig()
+			dnsConfig.AddRecord("dns.google", "", "8.8.8.8")
+			dnsRtx := testingx.NewDNSRoundTripperWithDNSConfig(dnsConfig)
+			listener := testingx.MustNewDNSOverUDPListener(udpAddr, &testingx.DNSOverUDPStdlibListener{}, dnsRtx)
 			defer listener.Close()
 			dialer := NewDialerWithoutResolver(model.DiscardLogger)
 			txp := NewUnwrappedDNSOverUDPTransport(dialer, listener.LocalAddr().String())
@@ -284,20 +280,20 @@ func TestDNSOverUDPTransport(t *testing.T) {
 	})
 
 	t.Run("recording delayed DNS responses", func(t *testing.T) {
+		dnsConfigGood := netem.NewDNSConfig()
+		dnsConfigGood.AddRecord("dns.google", "", "8.8.8.8")
+
+		dnsConfigBogus := netem.NewDNSConfig()
+		dnsConfigBogus.AddRecord("dns.google", "", "127.0.0.1")
+
 		t.Run("without any context-injected traces", func(t *testing.T) {
-			srvr := &filtering.DNSServer{
-				OnQuery: func(domain string) filtering.DNSAction {
-					return filtering.DNSActionLocalHostPlusCache
-				},
-				Cache: map[string][]string{
-					"dns.google.": {"8.8.8.8"},
-				},
-			}
-			listener, err := srvr.Start("127.0.0.1:0")
-			if err != nil {
-				t.Fatal(err)
+			udpAddr := &net.UDPAddr{
+				IP:   net.IPv4(127, 0, 0, 1),
+				Port: 0,
 			}
-			defer listener.Close()
+			listener := testingx.MustNewDNSSimulateGWFListener(
+				udpAddr, &testingx.DNSOverUDPStdlibListener{}, dnsConfigBogus,
+				dnsConfigGood, testingx.DNSNumBogusResponses(1))
 			dialer := NewDialerWithoutResolver(model.DiscardLogger)
 			expectedAddress := listener.LocalAddr().String()
 			txp := NewUnwrappedDNSOverUDPTransport(dialer, expectedAddress)
@@ -311,7 +307,7 @@ func TestDNSOverUDPTransport(t *testing.T) {
 			if _, err := rch.DecodeLookupHost(); err != nil {
 				t.Fatal(err)
 			}
-			// Now wait for the delayed response to arrive. We don't care much
+			// Now wait for the delayed responses to arrive. We don't care much
 			// about observing it here, rather we want to know it happened.
 			<-txp.lateResponses
 		})
@@ -325,18 +321,13 @@ func TestDNSOverUDPTransport(t *testing.T) {
 				goodLookupAddrs          bool
 				goodError                bool
 			)
-			srvr := &filtering.DNSServer{
-				OnQuery: func(domain string) filtering.DNSAction {
-					return filtering.DNSActionLocalHostPlusCache
-				},
-				Cache: map[string][]string{
-					"dns.google.": {"8.8.8.8"},
-				},
-			}
-			listener, err := srvr.Start("127.0.0.1:0")
-			if err != nil {
-				t.Fatal(err)
+			udpAddr := &net.UDPAddr{
+				IP:   net.IPv4(127, 0, 0, 1),
+				Port: 0,
 			}
+			listener := testingx.MustNewDNSSimulateGWFListener(
+				udpAddr, &testingx.DNSOverUDPStdlibListener{}, dnsConfigBogus,
+				dnsConfigGood, testingx.DNSNumBogusResponses(1))
 			defer listener.Close()
 			dialer := NewDialerWithoutResolver(model.DiscardLogger)
 			expectedAddress := listener.LocalAddr().String()
@@ -420,19 +411,14 @@ func TestDNSOverUDPTransport(t *testing.T) {
 				goodLookupAddrs          bool
 				goodError                bool
 			)
-			srvr := &filtering.DNSServer{
-				OnQuery: func(domain string) filtering.DNSAction {
-					return filtering.DNSActionLocalHostPlusCache
-				},
-				Cache: map[string][]string{
-					// Note: the cache here is nonexistent so we should
-					// get a "no such host" error from the server.
-				},
-			}
-			listener, err := srvr.Start("127.0.0.1:0")
-			if err != nil {
-				t.Fatal(err)
-			}
+			udpAddr := &net.UDPAddr{
+				IP:   net.IPv4(127, 0, 0, 1),
+				Port: 0,
+			}
+			// Note: the config here is empty so we should get a "no such host" error from the server.
+			listener := testingx.MustNewDNSSimulateGWFListener(
+				udpAddr, &testingx.DNSOverUDPStdlibListener{}, dnsConfigBogus,
+				netem.NewDNSConfig(), testingx.DNSNumBogusResponses(1))
 			defer listener.Close()
 			dialer := NewDialerWithoutResolver(model.DiscardLogger)
 			expectedAddress := listener.LocalAddr().String()