chore: merge probe-engine into probe-cli (#201)

This is how I did it:

1. `git clone https://github.com/ooni/probe-engine internal/engine`

2. ```
(cd internal/engine && git describe --tags)
v0.23.0
```

3. `nvim go.mod` (merging `go.mod` with `internal/engine/go.mod`

4. `rm -rf internal/.git internal/engine/go.{mod,sum}`

5. `git add internal/engine`

6. `find . -type f -name \*.go -exec sed -i 's@/ooni/probe-engine@/ooni/probe-cli/v3/internal/engine@g' {} \;`

7. `go build ./...` (passes)

8. `go test -race ./...` (temporary failure on RiseupVPN)

9. `go mod tidy`

10. this commit message

Once this piece of work is done, we can build a new version of `ooniprobe` that
is using `internal/engine` directly. We need to do more work to ensure all the
other functionality in `probe-engine` (e.g. making mobile packages) are still WAI.

Part of https://github.com/ooni/probe/issues/1335

internal/engine/experiment/hirl/fake_test.go

@@ -0,0 +1,71 @@
+package hirl_test
+
+import (
+	"context"
+	"io"
+	"net"
+	"time"
+)
+
+type FakeDialer struct {
+	Conn net.Conn
+	Err  error
+}
+
+func (d FakeDialer) DialContext(ctx context.Context, network, address string) (net.Conn, error) {
+	time.Sleep(10 * time.Microsecond)
+	return d.Conn, d.Err
+}
+
+type FakeConn struct {
+	ReadError             error
+	ReadData              []byte
+	SetDeadlineError      error
+	SetReadDeadlineError  error
+	SetWriteDeadlineError error
+	WriteError            error
+}
+
+func (c *FakeConn) Read(b []byte) (int, error) {
+	if len(c.ReadData) > 0 {
+		n := copy(b, c.ReadData)
+		c.ReadData = c.ReadData[n:]
+		return n, nil
+	}
+	if c.ReadError != nil {
+		return 0, c.ReadError
+	}
+	return 0, io.EOF
+}
+
+func (c *FakeConn) Write(b []byte) (n int, err error) {
+	if c.WriteError != nil {
+		return 0, c.WriteError
+	}
+	n = len(b)
+	return
+}
+
+func (*FakeConn) Close() (err error) {
+	return
+}
+
+func (*FakeConn) LocalAddr() net.Addr {
+	return &net.TCPAddr{}
+}
+
+func (*FakeConn) RemoteAddr() net.Addr {
+	return &net.TCPAddr{}
+}
+
+func (c *FakeConn) SetDeadline(t time.Time) (err error) {
+	return c.SetDeadlineError
+}
+
+func (c *FakeConn) SetReadDeadline(t time.Time) (err error) {
+	return c.SetReadDeadlineError
+}
+
+func (c *FakeConn) SetWriteDeadline(t time.Time) (err error) {
+	return c.SetWriteDeadlineError
+}

internal/engine/experiment/hirl/hirl.go

@@ -0,0 +1,323 @@
+// Package hirl contains the HTTP Invalid Request Line network experiment.
+//
+// See https://github.com/ooni/spec/blob/master/nettests/ts-007-http-invalid-request-line.md
+package hirl
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net"
+	"strings"
+	"time"
+
+	"github.com/ooni/probe-cli/v3/internal/engine/internal/randx"
+	"github.com/ooni/probe-cli/v3/internal/engine/model"
+	"github.com/ooni/probe-cli/v3/internal/engine/netx"
+	"github.com/ooni/probe-cli/v3/internal/engine/netx/archival"
+	"github.com/ooni/probe-cli/v3/internal/engine/netx/errorx"
+)
+
+const (
+	testName    = "http_invalid_request_line"
+	testVersion = "0.2.0"
+	timeout     = 5 * time.Second
+)
+
+// Config contains the experiment config.
+type Config struct{}
+
+// TestKeys contains the experiment test keys.
+type TestKeys struct {
+	FailureList   []*string                   `json:"failure_list"`
+	Received      []archival.MaybeBinaryValue `json:"received"`
+	Sent          []string                    `json:"sent"`
+	TamperingList []bool                      `json:"tampering_list"`
+	Tampering     bool                        `json:"tampering"`
+}
+
+// NewExperimentMeasurer creates a new ExperimentMeasurer.
+func NewExperimentMeasurer(config Config) model.ExperimentMeasurer {
+	return Measurer{
+		Config: config,
+		Methods: []Method{
+			randomInvalidMethod{},
+			randomInvalidFieldCount{},
+			randomBigRequestMethod{},
+			randomInvalidVersionNumber{},
+			squidCacheManager{},
+		},
+	}
+}
+
+// Measurer performs the measurement.
+type Measurer struct {
+	Config  Config
+	Methods []Method
+}
+
+// ExperimentName implements ExperimentMeasurer.ExperiExperimentName.
+func (m Measurer) ExperimentName() string {
+	return testName
+}
+
+// ExperimentVersion implements ExperimentMeasurer.ExperimentVersion.
+func (m Measurer) ExperimentVersion() string {
+	return testVersion
+}
+
+var (
+	// ErrNoAvailableTestHelpers is emitted when there are no available test helpers.
+	ErrNoAvailableTestHelpers = errors.New("no available helpers")
+
+	// ErrInvalidHelperType is emitted when the helper type is invalid.
+	ErrInvalidHelperType = errors.New("invalid helper type")
+
+	// ErrNoMeasurementMethod is emitted when Measurer.Methods is empty.
+	ErrNoMeasurementMethod = errors.New("no configured measurement method")
+)
+
+// Run implements ExperimentMeasurer.Run.
+func (m Measurer) Run(
+	ctx context.Context, sess model.ExperimentSession,
+	measurement *model.Measurement, callbacks model.ExperimentCallbacks,
+) error {
+	tk := new(TestKeys)
+	measurement.TestKeys = tk
+	if len(m.Methods) < 1 {
+		return ErrNoMeasurementMethod
+	}
+	const helperName = "tcp-echo"
+	helpers, ok := sess.GetTestHelpersByName(helperName)
+	if !ok || len(helpers) < 1 {
+		return ErrNoAvailableTestHelpers
+	}
+	helper := helpers[0]
+	if helper.Type != "legacy" {
+		return ErrInvalidHelperType
+	}
+	measurement.TestHelpers = map[string]interface{}{
+		"backend": helper.Address,
+	}
+	out := make(chan MethodResult)
+	for _, method := range m.Methods {
+		callbacks.OnProgress(0.0, fmt.Sprintf("%s...", method.Name()))
+		go method.Run(ctx, MethodConfig{
+			Address: helper.Address,
+			Logger:  sess.Logger(),
+			Out:     out,
+		})
+	}
+	var (
+		completed int
+		progress  float64
+		result    MethodResult
+	)
+	for {
+		select {
+		case result = <-out:
+		case <-time.After(500 * time.Millisecond):
+			if completed <= 0 {
+				progress += 0.05
+				callbacks.OnProgress(progress, "waiting for results...")
+			}
+			continue
+		}
+		failure := archival.NewFailure(result.Err)
+		tk.FailureList = append(tk.FailureList, failure)
+		tk.Received = append(tk.Received, result.Received)
+		tk.Sent = append(tk.Sent, result.Sent)
+		tk.TamperingList = append(tk.TamperingList, result.Tampering)
+		tk.Tampering = (tk.Tampering || result.Tampering)
+		completed++
+		percentage := (float64(completed)/float64(len(m.Methods)))*0.5 + 0.5
+		callbacks.OnProgress(percentage, fmt.Sprintf("%s... %+v", result.Name, result.Err))
+		if completed >= len(m.Methods) {
+			break
+		}
+	}
+	return nil
+}
+
+// MethodConfig contains the settings for a specific measuring method.
+type MethodConfig struct {
+	Address string
+	Logger  model.Logger
+	Out     chan<- MethodResult
+}
+
+// MethodResult is the result of one of the methods implemented by this experiment.
+type MethodResult struct {
+	Err       error
+	Name      string
+	Received  archival.MaybeBinaryValue
+	Sent      string
+	Tampering bool
+}
+
+// Method is one of the methods implemented by this experiment.
+type Method interface {
+	Name() string
+	Run(ctx context.Context, config MethodConfig)
+}
+
+type randomInvalidMethod struct{}
+
+func (randomInvalidMethod) Name() string {
+	return "random_invalid_method"
+}
+
+func (meth randomInvalidMethod) Run(ctx context.Context, config MethodConfig) {
+	RunMethod(ctx, RunMethodConfig{
+		MethodConfig: config,
+		Name:         meth.Name(),
+		RequestLine:  randx.LettersUppercase(4) + " / HTTP/1.1\n\r",
+	})
+}
+
+type randomInvalidFieldCount struct{}
+
+func (randomInvalidFieldCount) Name() string {
+	return "random_invalid_field_count"
+}
+
+func (meth randomInvalidFieldCount) Run(ctx context.Context, config MethodConfig) {
+	RunMethod(ctx, RunMethodConfig{
+		MethodConfig: config,
+		Name:         meth.Name(),
+		RequestLine: strings.Join([]string{
+			randx.LettersUppercase(5),
+			" ",
+			randx.LettersUppercase(5),
+			" ",
+			randx.LettersUppercase(5),
+			" ",
+			randx.LettersUppercase(5),
+			"\r\n",
+		}, ""),
+	})
+}
+
+type randomBigRequestMethod struct{}
+
+func (randomBigRequestMethod) Name() string {
+	return "random_big_request_method"
+}
+
+func (meth randomBigRequestMethod) Run(ctx context.Context, config MethodConfig) {
+	RunMethod(ctx, RunMethodConfig{
+		MethodConfig: config,
+		Name:         meth.Name(),
+		RequestLine: strings.Join([]string{
+			randx.LettersUppercase(1024),
+			" / HTTP/1.1\r\n",
+		}, ""),
+	})
+}
+
+type randomInvalidVersionNumber struct{}
+
+func (randomInvalidVersionNumber) Name() string {
+	return "random_invalid_version_number"
+}
+
+func (meth randomInvalidVersionNumber) Run(ctx context.Context, config MethodConfig) {
+	RunMethod(ctx, RunMethodConfig{
+		MethodConfig: config,
+		Name:         meth.Name(),
+		RequestLine: strings.Join([]string{
+			"GET / HTTP/",
+			randx.LettersUppercase(3),
+			"\r\n",
+		}, ""),
+	})
+}
+
+type squidCacheManager struct{}
+
+func (squidCacheManager) Name() string {
+	return "squid_cache_manager"
+}
+
+func (meth squidCacheManager) Run(ctx context.Context, config MethodConfig) {
+	RunMethod(ctx, RunMethodConfig{
+		MethodConfig: config,
+		Name:         meth.Name(),
+		RequestLine:  "GET cache_object://localhost/ HTTP/1.0\n\r",
+	})
+}
+
+// RunMethodConfig contains the config for RunMethod
+type RunMethodConfig struct {
+	MethodConfig
+	Name        string
+	NewDialer   func(config netx.Config) netx.Dialer
+	RequestLine string
+}
+
+// RunMethod runs the specific method using the given config and context
+func RunMethod(ctx context.Context, config RunMethodConfig) {
+	ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
+	defer cancel()
+	result := MethodResult{Name: config.Name}
+	defer func() {
+		config.Out <- result
+	}()
+	if config.NewDialer == nil {
+		config.NewDialer = netx.NewDialer
+	}
+	dialer := config.NewDialer(netx.Config{
+		ContextByteCounting: true,
+		Logger:              config.Logger,
+	})
+	conn, err := dialer.DialContext(ctx, "tcp", net.JoinHostPort(config.Address, "80"))
+	if err != nil {
+		result.Err = err
+		return
+	}
+	deadline := time.Now().Add(timeout)
+	if err := conn.SetDeadline(deadline); err != nil {
+		result.Err = err
+		return
+	}
+	if _, err := conn.Write([]byte(config.RequestLine)); err != nil {
+		result.Err = err
+		return
+	}
+	result.Sent = config.RequestLine
+	data := make([]byte, 4096)
+	defer func() {
+		result.Tampering = (result.Sent != result.Received.Value)
+	}()
+	for {
+		count, err := conn.Read(data)
+		if err != nil {
+			// We expect this method to terminate w/ timeout
+			if err.Error() == errorx.FailureGenericTimeoutError {
+				err = nil
+			}
+			result.Err = err
+			return
+		}
+		result.Received.Value += string(data[:count])
+	}
+}
+
+// SummaryKeys contains summary keys for this experiment.
+//
+// Note that this structure is part of the ABI contract with probe-cli
+// therefore we should be careful when changing it.
+type SummaryKeys struct {
+	IsAnomaly bool `json:"-"`
+}
+
+// GetSummaryKeys implements model.ExperimentMeasurer.GetSummaryKeys.
+func (m Measurer) GetSummaryKeys(measurement *model.Measurement) (interface{}, error) {
+	sk := SummaryKeys{IsAnomaly: false}
+	tk, ok := measurement.TestKeys.(*TestKeys)
+	if !ok {
+		return sk, errors.New("invalid test keys type")
+	}
+	sk.IsAnomaly = tk.Tampering
+	return sk, nil
+}

internal/engine/experiment/hirl/hirl_test.go

@@ -0,0 +1,598 @@
+package hirl_test
+
+import (
+	"context"
+	"errors"
+	"io"
+	"testing"
+
+	"github.com/apex/log"
+	"github.com/ooni/probe-cli/v3/internal/engine/experiment/hirl"
+	"github.com/ooni/probe-cli/v3/internal/engine/internal/mockable"
+	"github.com/ooni/probe-cli/v3/internal/engine/model"
+	"github.com/ooni/probe-cli/v3/internal/engine/netx"
+	"github.com/ooni/probe-cli/v3/internal/engine/netx/archival"
+	"github.com/ooni/probe-cli/v3/internal/engine/netx/errorx"
+)
+
+func TestNewExperimentMeasurer(t *testing.T) {
+	measurer := hirl.NewExperimentMeasurer(hirl.Config{})
+	if measurer.ExperimentName() != "http_invalid_request_line" {
+		t.Fatal("unexpected name")
+	}
+	if measurer.ExperimentVersion() != "0.2.0" {
+		t.Fatal("unexpected version")
+	}
+}
+
+func TestSuccess(t *testing.T) {
+	measurer := hirl.NewExperimentMeasurer(hirl.Config{})
+	ctx := context.Background()
+	sess := &mockable.Session{
+		MockableLogger: log.Log,
+		MockableTestHelpers: map[string][]model.Service{
+			"tcp-echo": {{
+				Address: "37.218.241.93",
+				Type:    "legacy",
+			}},
+		},
+	}
+	measurement := new(model.Measurement)
+	callbacks := model.NewPrinterCallbacks(log.Log)
+	err := measurer.Run(ctx, sess, measurement, callbacks)
+	if err != nil {
+		t.Fatal(err)
+	}
+	tk := measurement.TestKeys.(*hirl.TestKeys)
+	if len(tk.FailureList) != len(tk.Received) {
+		t.Fatal("FailureList and Received have different lengths")
+	}
+	if len(tk.Received) != len(tk.Sent) {
+		t.Fatal("Received and Sent have different lengths")
+	}
+	if len(tk.Sent) != len(tk.TamperingList) {
+		t.Fatal("Sent and TamperingList have different lengths")
+	}
+	for _, failure := range tk.FailureList {
+		if failure != nil {
+			t.Fatal(*failure)
+		}
+	}
+	for idx, received := range tk.Received {
+		if received.Value != tk.Sent[idx] {
+			t.Fatal("mismatch between received and sent")
+		}
+	}
+	for _, entry := range tk.TamperingList {
+		if entry != false {
+			t.Fatal("found entry with tampering")
+		}
+	}
+	if tk.Tampering != false {
+		t.Fatal("overall there is tampering?!")
+	}
+}
+
+func TestCancelledContext(t *testing.T) {
+	measurer := hirl.NewExperimentMeasurer(hirl.Config{})
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+	sess := &mockable.Session{
+		MockableLogger: log.Log,
+		MockableTestHelpers: map[string][]model.Service{
+			"tcp-echo": {{
+				Address: "37.218.241.93",
+				Type:    "legacy",
+			}},
+		},
+	}
+	measurement := new(model.Measurement)
+	callbacks := model.NewPrinterCallbacks(log.Log)
+	err := measurer.Run(ctx, sess, measurement, callbacks)
+	if err != nil {
+		t.Fatal(err)
+	}
+	tk := measurement.TestKeys.(*hirl.TestKeys)
+	if len(tk.FailureList) != 5 {
+		t.Fatal("unexpected FailureList length")
+	}
+	for _, failure := range tk.FailureList {
+		if *failure != errorx.FailureInterrupted {
+			t.Fatal("unexpected failure")
+		}
+	}
+	if len(tk.Received) != 5 {
+		t.Fatal("unexpected Received length")
+	}
+	for _, entry := range tk.Received {
+		if entry.Value != "" {
+			t.Fatal("unexpected received entry")
+		}
+	}
+	if len(tk.Sent) != 5 {
+		t.Fatal("unexpected Sent length")
+	}
+	for _, entry := range tk.Sent {
+		if entry != "" {
+			t.Fatal("unexpected sent entry")
+		}
+	}
+	if len(tk.TamperingList) != 5 {
+		t.Fatal("unexpected TamperingList length")
+	}
+	for _, entry := range tk.TamperingList {
+		if entry != false {
+			t.Fatal("unexpected tampering entry")
+		}
+	}
+	if tk.Tampering != false {
+		t.Fatal("overall there is tampering?!")
+	}
+	sk, err := measurer.GetSummaryKeys(measurement)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, ok := sk.(hirl.SummaryKeys); !ok {
+		t.Fatal("invalid type for summary keys")
+	}
+}
+
+type FakeMethodSuccessful struct{}
+
+func (FakeMethodSuccessful) Name() string {
+	return "success"
+}
+
+func (meth FakeMethodSuccessful) Run(ctx context.Context, config hirl.MethodConfig) {
+	config.Out <- hirl.MethodResult{
+		Name:      meth.Name(),
+		Received:  archival.MaybeBinaryValue{Value: "antani"},
+		Sent:      "antani",
+		Tampering: false,
+	}
+}
+
+type FakeMethodFailure struct{}
+
+func (FakeMethodFailure) Name() string {
+	return "failure"
+}
+
+func (meth FakeMethodFailure) Run(ctx context.Context, config hirl.MethodConfig) {
+	config.Out <- hirl.MethodResult{
+		Name:      meth.Name(),
+		Received:  archival.MaybeBinaryValue{Value: "antani"},
+		Sent:      "melandri",
+		Tampering: true,
+	}
+}
+
+func TestWithFakeMethods(t *testing.T) {
+	measurer := hirl.Measurer{
+		Config: hirl.Config{},
+		Methods: []hirl.Method{
+			FakeMethodSuccessful{},
+			FakeMethodFailure{},
+			FakeMethodSuccessful{},
+		},
+	}
+	ctx := context.Background()
+	sess := &mockable.Session{
+		MockableTestHelpers: map[string][]model.Service{
+			"tcp-echo": {{
+				Address: "127.0.0.1",
+				Type:    "legacy",
+			}},
+		},
+	}
+	measurement := new(model.Measurement)
+	callbacks := model.NewPrinterCallbacks(log.Log)
+	err := measurer.Run(ctx, sess, measurement, callbacks)
+	if err != nil {
+		t.Fatal(err)
+	}
+	tk := measurement.TestKeys.(*hirl.TestKeys)
+	if len(tk.FailureList) != len(tk.Received) {
+		t.Fatal("FailureList and Received have different lengths")
+	}
+	if len(tk.Received) != len(tk.Sent) {
+		t.Fatal("Received and Sent have different lengths")
+	}
+	if len(tk.Sent) != len(tk.TamperingList) {
+		t.Fatal("Sent and TamperingList have different lengths")
+	}
+	for _, failure := range tk.FailureList {
+		if failure != nil {
+			t.Fatal(*failure)
+		}
+	}
+	for _, received := range tk.Received {
+		if received.Value != "antani" {
+			t.Fatal("unexpected received value")
+		}
+	}
+	for _, sent := range tk.Sent {
+		if sent != "antani" && sent != "melandri" {
+			t.Fatal("unexpected sent value")
+		}
+	}
+	var falses, trues int
+	for _, entry := range tk.TamperingList {
+		if entry {
+			trues++
+		} else {
+			falses++
+		}
+	}
+	if falses != 2 && trues != 1 {
+		t.Fatal("not the right values in tampering list")
+	}
+	if tk.Tampering != true {
+		t.Fatal("overall there is no tampering?!")
+	}
+}
+
+func TestWithNoMethods(t *testing.T) {
+	measurer := hirl.Measurer{
+		Config:  hirl.Config{},
+		Methods: []hirl.Method{},
+	}
+	ctx := context.Background()
+	sess := &mockable.Session{
+		MockableTestHelpers: map[string][]model.Service{
+			"tcp-echo": {{
+				Address: "127.0.0.1",
+				Type:    "legacy",
+			}},
+		},
+	}
+	measurement := new(model.Measurement)
+	callbacks := model.NewPrinterCallbacks(log.Log)
+	err := measurer.Run(ctx, sess, measurement, callbacks)
+	if !errors.Is(err, hirl.ErrNoMeasurementMethod) {
+		t.Fatal("not the error we expected")
+	}
+	tk := measurement.TestKeys.(*hirl.TestKeys)
+	if len(tk.FailureList) != 0 {
+		t.Fatal("unexpected FailureList length")
+	}
+	if len(tk.Received) != 0 {
+		t.Fatal("unexpected Received length")
+	}
+	if len(tk.Sent) != 0 {
+		t.Fatal("unexpected Sent length")
+	}
+	if len(tk.TamperingList) != 0 {
+		t.Fatal("unexpected TamperingList length")
+	}
+	if tk.Tampering != false {
+		t.Fatal("overall there is tampering?!")
+	}
+}
+
+func TestNoHelpers(t *testing.T) {
+	measurer := hirl.NewExperimentMeasurer(hirl.Config{})
+	ctx := context.Background()
+	sess := &mockable.Session{}
+	measurement := new(model.Measurement)
+	callbacks := model.NewPrinterCallbacks(log.Log)
+	err := measurer.Run(ctx, sess, measurement, callbacks)
+	if !errors.Is(err, hirl.ErrNoAvailableTestHelpers) {
+		t.Fatal("not the error we expected")
+	}
+	tk := measurement.TestKeys.(*hirl.TestKeys)
+	if len(tk.FailureList) != 0 {
+		t.Fatal("expected an empty FailureList")
+	}
+	if len(tk.FailureList) != len(tk.Received) {
+		t.Fatal("FailureList and Received have different lengths")
+	}
+	if len(tk.Received) != len(tk.Sent) {
+		t.Fatal("Received and Sent have different lengths")
+	}
+	if len(tk.Sent) != len(tk.TamperingList) {
+		t.Fatal("Sent and TamperingList have different lengths")
+	}
+	if tk.Tampering != false {
+		t.Fatal("overall there is tampering?!")
+	}
+}
+
+func TestNoActualHelperInList(t *testing.T) {
+	measurer := hirl.NewExperimentMeasurer(hirl.Config{})
+	ctx := context.Background()
+	sess := &mockable.Session{
+		MockableTestHelpers: map[string][]model.Service{
+			"tcp-echo": nil,
+		},
+	}
+	measurement := new(model.Measurement)
+	callbacks := model.NewPrinterCallbacks(log.Log)
+	err := measurer.Run(ctx, sess, measurement, callbacks)
+	if !errors.Is(err, hirl.ErrNoAvailableTestHelpers) {
+		t.Fatal("not the error we expected")
+	}
+	tk := measurement.TestKeys.(*hirl.TestKeys)
+	if len(tk.FailureList) != 0 {
+		t.Fatal("expected an empty FailureList")
+	}
+	if len(tk.FailureList) != len(tk.Received) {
+		t.Fatal("FailureList and Received have different lengths")
+	}
+	if len(tk.Received) != len(tk.Sent) {
+		t.Fatal("Received and Sent have different lengths")
+	}
+	if len(tk.Sent) != len(tk.TamperingList) {
+		t.Fatal("Sent and TamperingList have different lengths")
+	}
+	if tk.Tampering != false {
+		t.Fatal("overall there is tampering?!")
+	}
+}
+
+func TestWrongTestHelperType(t *testing.T) {
+	measurer := hirl.NewExperimentMeasurer(hirl.Config{})
+	ctx := context.Background()
+	sess := &mockable.Session{
+		MockableTestHelpers: map[string][]model.Service{
+			"tcp-echo": {{
+				Address: "127.0.0.1",
+				Type:    "antani",
+			}},
+		},
+	}
+	measurement := new(model.Measurement)
+	callbacks := model.NewPrinterCallbacks(log.Log)
+	err := measurer.Run(ctx, sess, measurement, callbacks)
+	if !errors.Is(err, hirl.ErrInvalidHelperType) {
+		t.Fatal("not the error we expected")
+	}
+	tk := measurement.TestKeys.(*hirl.TestKeys)
+	if len(tk.FailureList) != 0 {
+		t.Fatal("expected an empty FailureList")
+	}
+	if len(tk.FailureList) != len(tk.Received) {
+		t.Fatal("FailureList and Received have different lengths")
+	}
+	if len(tk.Received) != len(tk.Sent) {
+		t.Fatal("Received and Sent have different lengths")
+	}
+	if len(tk.Sent) != len(tk.TamperingList) {
+		t.Fatal("Sent and TamperingList have different lengths")
+	}
+	if tk.Tampering != false {
+		t.Fatal("overall there is tampering?!")
+	}
+}
+
+func TestRunMethodDialFailure(t *testing.T) {
+	sess := &mockable.Session{
+		MockableLogger: log.Log,
+		MockableTestHelpers: map[string][]model.Service{
+			"tcp-echo": {{
+				Address: "37.218.241.93",
+				Type:    "legacy",
+			}},
+		},
+	}
+	helpers, ok := sess.GetTestHelpersByName("tcp-echo")
+	if len(helpers) < 1 || !ok {
+		t.Fatal("cannot get helper")
+	}
+	expected := errors.New("mocked error")
+	out := make(chan hirl.MethodResult)
+	config := hirl.RunMethodConfig{
+		MethodConfig: hirl.MethodConfig{
+			Address: helpers[0].Address,
+			Logger:  log.Log,
+			Out:     out,
+		},
+		Name: "random_invalid_version_number",
+		NewDialer: func(config netx.Config) netx.Dialer {
+			return FakeDialer{Err: expected}
+		},
+		RequestLine: "GET / HTTP/ABC",
+	}
+	go hirl.RunMethod(context.Background(), config)
+	result := <-out
+	if !errors.Is(result.Err, expected) {
+		t.Fatal("not the error we expected")
+	}
+	if result.Name != "random_invalid_version_number" {
+		t.Fatal("unexpected Name")
+	}
+	if result.Received.Value != "" {
+		t.Fatal("unexpected Received.Value")
+	}
+	if result.Sent != "" {
+		t.Fatal("unexpected Sent")
+	}
+	if result.Tampering != false {
+		t.Fatal("unexpected Tampering")
+	}
+}
+
+func TestRunMethodSetDeadlineFailure(t *testing.T) {
+	sess := &mockable.Session{
+		MockableLogger: log.Log,
+		MockableTestHelpers: map[string][]model.Service{
+			"tcp-echo": {{
+				Address: "37.218.241.93",
+				Type:    "legacy",
+			}},
+		},
+	}
+	helpers, ok := sess.GetTestHelpersByName("tcp-echo")
+	if len(helpers) < 1 || !ok {
+		t.Fatal("cannot get helper")
+	}
+	expected := errors.New("mocked error")
+	out := make(chan hirl.MethodResult)
+	config := hirl.RunMethodConfig{
+		MethodConfig: hirl.MethodConfig{
+			Address: helpers[0].Address,
+			Logger:  log.Log,
+			Out:     out,
+		},
+		Name: "random_invalid_version_number",
+		NewDialer: func(config netx.Config) netx.Dialer {
+			return FakeDialer{Conn: &FakeConn{
+				SetDeadlineError: expected,
+			}}
+		},
+		RequestLine: "GET / HTTP/ABC",
+	}
+	go hirl.RunMethod(context.Background(), config)
+	result := <-out
+	if !errors.Is(result.Err, expected) {
+		t.Fatal("not the error we expected")
+	}
+	if result.Name != "random_invalid_version_number" {
+		t.Fatal("unexpected Name")
+	}
+	if result.Received.Value != "" {
+		t.Fatal("unexpected Received.Value")
+	}
+	if result.Sent != "" {
+		t.Fatal("unexpected Sent")
+	}
+	if result.Tampering != false {
+		t.Fatal("unexpected Tampering")
+	}
+}
+
+func TestRunMethodWriteFailure(t *testing.T) {
+	sess := &mockable.Session{
+		MockableLogger: log.Log,
+		MockableTestHelpers: map[string][]model.Service{
+			"tcp-echo": {{
+				Address: "37.218.241.93",
+				Type:    "legacy",
+			}},
+		},
+	}
+	helpers, ok := sess.GetTestHelpersByName("tcp-echo")
+	if len(helpers) < 1 || !ok {
+		t.Fatal("cannot get helper")
+	}
+	expected := errors.New("mocked error")
+	out := make(chan hirl.MethodResult)
+	config := hirl.RunMethodConfig{
+		MethodConfig: hirl.MethodConfig{
+			Address: helpers[0].Address,
+			Logger:  log.Log,
+			Out:     out,
+		},
+		Name: "random_invalid_version_number",
+		NewDialer: func(config netx.Config) netx.Dialer {
+			return FakeDialer{Conn: &FakeConn{
+				WriteError: expected,
+			}}
+		},
+		RequestLine: "GET / HTTP/ABC",
+	}
+	go hirl.RunMethod(context.Background(), config)
+	result := <-out
+	if !errors.Is(result.Err, expected) {
+		t.Fatal("not the error we expected")
+	}
+	if result.Name != "random_invalid_version_number" {
+		t.Fatal("unexpected Name")
+	}
+	if result.Received.Value != "" {
+		t.Fatal("unexpected Received.Value")
+	}
+	if result.Sent != "" {
+		t.Fatal("unexpected Sent")
+	}
+	if result.Tampering != false {
+		t.Fatal("unexpected Tampering")
+	}
+}
+
+func TestRunMethodReadEOFWithWrongData(t *testing.T) {
+	sess := &mockable.Session{
+		MockableLogger: log.Log,
+		MockableTestHelpers: map[string][]model.Service{
+			"tcp-echo": {{
+				Address: "37.218.241.93",
+				Type:    "legacy",
+			}},
+		},
+	}
+	helpers, ok := sess.GetTestHelpersByName("tcp-echo")
+	if len(helpers) < 1 || !ok {
+		t.Fatal("cannot get helper")
+	}
+	out := make(chan hirl.MethodResult)
+	config := hirl.RunMethodConfig{
+		MethodConfig: hirl.MethodConfig{
+			Address: helpers[0].Address,
+			Logger:  log.Log,
+			Out:     out,
+		},
+		Name: "random_invalid_version_number",
+		NewDialer: func(config netx.Config) netx.Dialer {
+			return FakeDialer{Conn: &FakeConn{
+				ReadData: []byte("0xdeadbeef"),
+			}}
+		},
+		RequestLine: "GET / HTTP/ABC",
+	}
+	go hirl.RunMethod(context.Background(), config)
+	result := <-out
+	if !errors.Is(result.Err, io.EOF) {
+		t.Fatal("not the error we expected")
+	}
+	if result.Name != "random_invalid_version_number" {
+		t.Fatal("unexpected Name")
+	}
+	if result.Received.Value != "0xdeadbeef" {
+		t.Fatal("unexpected Received.Value")
+	}
+	if result.Sent != "GET / HTTP/ABC" {
+		t.Fatal("unexpected Sent")
+	}
+	if result.Tampering != true {
+		t.Fatal("unexpected Tampering")
+	}
+}
+
+func TestSummaryKeysInvalidType(t *testing.T) {
+	measurement := new(model.Measurement)
+	m := &hirl.Measurer{}
+	_, err := m.GetSummaryKeys(measurement)
+	if err.Error() != "invalid test keys type" {
+		t.Fatal("not the error we expected")
+	}
+}
+
+func TestSummaryKeysFalse(t *testing.T) {
+	measurement := &model.Measurement{TestKeys: &hirl.TestKeys{
+		Tampering: false,
+	}}
+	m := &hirl.Measurer{}
+	osk, err := m.GetSummaryKeys(measurement)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sk := osk.(hirl.SummaryKeys)
+	if sk.IsAnomaly {
+		t.Fatal("invalid isAnomaly")
+	}
+}
+
+func TestSummaryKeysTrue(t *testing.T) {
+	measurement := &model.Measurement{TestKeys: &hirl.TestKeys{
+		Tampering: true,
+	}}
+	m := &hirl.Measurer{}
+	osk, err := m.GetSummaryKeys(measurement)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sk := osk.(hirl.SummaryKeys)
+	if sk.IsAnomaly == false {
+		t.Fatal("invalid isAnomaly")
+	}
+}