refactor(session.go): replace engine/netx with netxlite (#767)

This diff replaces engine/netx code with netxlite code in
the engine/session.go file. To this end, we needed to move
some code from engine/netx to netxlite. While there, we
did review and improve the unit tests.

A notable change in this diff is (or seems to be) that in
engine/session.go we're not filtering for bogons anymore so
that, in principle, we could believe a resolver returning
to us bogon IP addresses for OONI services. However, I did
not bother with changing bogons filtering because the
sessionresolver package is already filtering for bogons,
so it is actually okay to avoid doing that again the
session.go code. See:

https://github.com/ooni/probe-cli/blob/v3.15.0-alpha.1/internal/engine/internal/sessionresolver/resolvermaker.go#L88

There are two reference issues for this cleanup:

1. https://github.com/ooni/probe/issues/2115

2. https://github.com/ooni/probe/issues/2121

internal/bytecounter/http_test.go

@@ -0,0 +1,162 @@
+package bytecounter
+
+import (
+	"context"
+	"errors"
+	"io"
+	"net/http"
+	"strings"
+	"testing"
+
+	"github.com/ooni/probe-cli/v3/internal/model/mocks"
+	"github.com/ooni/probe-cli/v3/internal/netxlite"
+)
+
+func TestHTTPTransport(t *testing.T) {
+	t.Run("RoundTrip", func(t *testing.T) {
+		t.Run("failure", func(t *testing.T) {
+			counter := New()
+			txp := &HTTPTransport{
+				Counter: counter,
+				HTTPTransport: &mocks.HTTPTransport{
+					MockRoundTrip: func(req *http.Request) (*http.Response, error) {
+						return nil, io.EOF
+					},
+				},
+			}
+			req, err := http.NewRequest(
+				"POST", "https://www.google.com", strings.NewReader("AAAAAA"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			req.Header.Set("User-Agent", "antani-browser/1.0.0")
+			resp, err := txp.RoundTrip(req)
+			if !errors.Is(err, io.EOF) {
+				t.Fatal("not the error we expected")
+			}
+			if resp != nil {
+				t.Fatal("expected nil response here")
+			}
+			if counter.Sent.Load() != 62 {
+				t.Fatal("expected 62 bytes sent", counter.Sent.Load())
+			}
+			if counter.Received.Load() != 0 {
+				t.Fatal("expected zero bytes received", counter.Received.Load())
+			}
+		})
+
+		t.Run("success", func(t *testing.T) {
+			counter := New()
+			txp := &HTTPTransport{
+				Counter: counter,
+				HTTPTransport: &mocks.HTTPTransport{
+					MockRoundTrip: func(req *http.Request) (*http.Response, error) {
+						resp := &http.Response{
+							Body: io.NopCloser(strings.NewReader("1234567")),
+							Header: http.Header{
+								"Server": []string{"antani/0.1.0"},
+							},
+							Status:     "200 OK",
+							StatusCode: http.StatusOK,
+						}
+						return resp, nil
+					},
+				},
+			}
+			req, err := http.NewRequest(
+				"POST", "https://www.google.com", strings.NewReader("AAAAAA"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			req.Header.Set("User-Agent", "antani-browser/1.0.0")
+			resp, err := txp.RoundTrip(req)
+			if err != nil {
+				t.Fatal(err)
+			}
+			data, err := netxlite.ReadAllContext(context.Background(), resp.Body)
+			if err != nil {
+				t.Fatal(err)
+			}
+			resp.Body.Close()
+			if string(data) != "1234567" {
+				t.Fatal("expected a different body here")
+			}
+			if counter.Sent.Load() != 62 {
+				t.Fatal("expected 62 bytes sent", counter.Sent.Load())
+			}
+			if counter.Received.Load() != 37 {
+				t.Fatal("expected 37 bytes received", counter.Received.Load())
+			}
+		})
+
+		t.Run("success with EOF", func(t *testing.T) {
+			counter := New()
+			txp := &HTTPTransport{
+				Counter: counter,
+				HTTPTransport: &mocks.HTTPTransport{
+					MockRoundTrip: func(req *http.Request) (*http.Response, error) {
+						resp := &http.Response{
+							Body: io.NopCloser(&mocks.Reader{
+								MockRead: func(b []byte) (int, error) {
+									if len(b) < 1 {
+										panic("should not happen")
+									}
+									b[0] = 'A'
+									return 1, io.EOF // we want code to be robust to this
+								},
+							}),
+							Header: http.Header{
+								"Server": []string{"antani/0.1.0"},
+							},
+							Status:     "200 OK",
+							StatusCode: http.StatusOK,
+						}
+						return resp, nil
+					},
+				},
+			}
+			client := &http.Client{Transport: txp}
+			resp, err := client.Get("https://www.google.com")
+			if err != nil {
+				t.Fatal(err)
+			}
+			data, err := netxlite.ReadAllContext(context.Background(), resp.Body)
+			if err != nil {
+				t.Fatal(err)
+			}
+			resp.Body.Close()
+			if string(data) != "A" {
+				t.Fatal("expected a different body here")
+			}
+		})
+	})
+
+	t.Run("CloseIdleConnections", func(t *testing.T) {
+		var called bool
+		child := &mocks.HTTPTransport{
+			MockCloseIdleConnections: func() {
+				called = true
+			},
+		}
+		counter := New()
+		txp := NewHTTPTransport(child, counter)
+		txp.CloseIdleConnections()
+		if !called {
+			t.Fatal("not called")
+		}
+	})
+
+	t.Run("Network", func(t *testing.T) {
+		expected := "antani"
+		child := &mocks.HTTPTransport{
+			MockNetwork: func() string {
+				return expected
+			},
+		}
+		counter := New()
+		txp := NewHTTPTransport(child, counter)
+		if network := txp.Network(); network != expected {
+			t.Fatal("unexpected network", network)
+		}
+	})
+}