Add Sender module

2025-07-01 18:47:29 -04:00 · 2022-02-22 14:10:39 +01:00
parent afa211d0ec
commit efc20564c1
58 changed files with 9131 additions and 282 deletions
--- a/pkg/db/badger/sender_test.go
+++ b/pkg/db/badger/sender_test.go
@ -0,0 +1,204 @@
+package badger_test
+
+import (
+	"context"
+	"errors"
+	"math/rand"
+	"net/http"
+	"net/url"
+	"testing"
+	"time"
+
+	badgerdb "github.com/dgraph-io/badger/v3"
+	"github.com/google/go-cmp/cmp"
+	"github.com/oklog/ulid"
+
+	"github.com/dstotijn/hetty/pkg/db/badger"
+	"github.com/dstotijn/hetty/pkg/reqlog"
+	"github.com/dstotijn/hetty/pkg/sender"
+)
+
+//nolint:gosec
+var ulidEntropy = rand.New(rand.NewSource(time.Now().UnixNano()))
+
+var exampleURL = func() *url.URL {
+	u, err := url.Parse("https://example.com/foobar")
+	if err != nil {
+		panic(err)
+	}
+
+	return u
+}()
+
+func TestFindRequestByID(t *testing.T) {
+	t.Parallel()
+
+	database, err := badger.OpenDatabase(badgerdb.DefaultOptions("").WithInMemory(true))
+	if err != nil {
+		t.Fatalf("failed to open badger database: %v", err)
+	}
+	defer database.Close()
+
+	// See: https://go.dev/blog/subtests#cleaning-up-after-a-group-of-parallel-tests
+	t.Run("group", func(t *testing.T) {
+		t.Run("sender request not found", func(t *testing.T) {
+			t.Parallel()
+
+			_, err := database.FindSenderRequestByID(context.Background(), ulid.ULID{})
+			if !errors.Is(err, sender.ErrRequestNotFound) {
+				t.Fatalf("expected `sender.ErrRequestNotFound`, got: %v", err)
+			}
+		})
+
+		t.Run("sender request found", func(t *testing.T) {
+			t.Parallel()
+
+			exp := sender.Request{
+				ID:                 ulid.MustNew(ulid.Timestamp(time.Now()), ulidEntropy),
+				ProjectID:          ulid.MustNew(ulid.Timestamp(time.Now()), ulidEntropy),
+				SourceRequestLogID: ulid.MustNew(ulid.Timestamp(time.Now()), ulidEntropy),
+
+				URL:    exampleURL,
+				Method: http.MethodGet,
+				Proto:  sender.HTTPProto2,
+				Header: http.Header{
+					"X-Foo": []string{"bar"},
+				},
+				Body: []byte("foo"),
+			}
+
+			err := database.StoreSenderRequest(context.Background(), exp)
+			if err != nil {
+				t.Fatalf("unexpected error (expected: nil, got: %v)", err)
+			}
+
+			resLog := reqlog.ResponseLog{
+				Proto:      "HTTP/2.0",
+				Status:     "200 OK",
+				StatusCode: 200,
+				Header: http.Header{
+					"X-Yolo": []string{"swag"},
+				},
+				Body: []byte("bar"),
+			}
+
+			err = database.StoreResponseLog(context.Background(), exp.ID, resLog)
+			if err != nil {
+				t.Fatalf("unexpected error (expected: nil, got: %v)", err)
+			}
+
+			exp.Response = &resLog
+
+			got, err := database.FindSenderRequestByID(context.Background(), exp.ID)
+			if err != nil {
+				t.Fatalf("unexpected error (expected: nil, got: %v)", err)
+			}
+
+			if diff := cmp.Diff(exp, got); diff != "" {
+				t.Fatalf("sender request not equal (-exp, +got):\n%v", diff)
+			}
+		})
+	})
+}
+
+func TestFindSenderRequests(t *testing.T) {
+	t.Parallel()
+
+	t.Run("without project ID in filter", func(t *testing.T) {
+		t.Parallel()
+
+		database, err := badger.OpenDatabase(badgerdb.DefaultOptions("").WithInMemory(true))
+		if err != nil {
+			t.Fatalf("failed to open badger database: %v", err)
+		}
+		defer database.Close()
+
+		filter := sender.FindRequestsFilter{}
+
+		_, err = database.FindSenderRequests(context.Background(), filter, nil)
+		if !errors.Is(err, sender.ErrProjectIDMustBeSet) {
+			t.Fatalf("expected `sender.ErrProjectIDMustBeSet`, got: %v", err)
+		}
+	})
+
+	t.Run("returns sender requests and related response logs", func(t *testing.T) {
+		t.Parallel()
+
+		database, err := badger.OpenDatabase(badgerdb.DefaultOptions("").WithInMemory(true))
+		if err != nil {
+			t.Fatalf("failed to open badger database: %v", err)
+		}
+		defer database.Close()
+
+		projectID := ulid.MustNew(ulid.Timestamp(time.Now()), ulidEntropy)
+
+		fixtures := []sender.Request{
+			{
+				ID:                 ulid.MustNew(ulid.Timestamp(time.Now()), ulidEntropy),
+				ProjectID:          projectID,
+				SourceRequestLogID: ulid.MustNew(ulid.Timestamp(time.Now()), ulidEntropy),
+				URL:                exampleURL,
+				Method:             http.MethodPost,
+				Proto:              "HTTP/1.1",
+				Header: http.Header{
+					"X-Foo": []string{"baz"},
+				},
+				Body: []byte("foo"),
+				Response: &reqlog.ResponseLog{
+					Proto:      "HTTP/1.1",
+					Status:     "200 OK",
+					StatusCode: 200,
+					Header: http.Header{
+						"X-Yolo": []string{"swag"},
+					},
+					Body: []byte("bar"),
+				},
+			},
+			{
+				ID:                 ulid.MustNew(ulid.Timestamp(time.Now())+100, ulidEntropy),
+				ProjectID:          projectID,
+				SourceRequestLogID: ulid.MustNew(ulid.Timestamp(time.Now()), ulidEntropy),
+				URL:                exampleURL,
+				Method:             http.MethodGet,
+				Proto:              "HTTP/1.1",
+				Header: http.Header{
+					"X-Foo": []string{"baz"},
+				},
+			},
+		}
+
+		// Store fixtures.
+		for _, senderReq := range fixtures {
+			err = database.StoreSenderRequest(context.Background(), senderReq)
+			if err != nil {
+				t.Fatalf("unexpected error creating request log fixture: %v", err)
+			}
+
+			if senderReq.Response != nil {
+				err = database.StoreResponseLog(context.Background(), senderReq.ID, *senderReq.Response)
+				if err != nil {
+					t.Fatalf("unexpected error creating response log fixture: %v", err)
+				}
+			}
+		}
+
+		filter := sender.FindRequestsFilter{
+			ProjectID: projectID,
+		}
+
+		got, err := database.FindSenderRequests(context.Background(), filter, nil)
+		if err != nil {
+			t.Fatalf("unexpected error finding sender requests: %v", err)
+		}
+
+		// We expect the found sender requests are *reversed*, e.g. newest first.
+		exp := make([]sender.Request, len(fixtures))
+		for i, j := 0, len(fixtures)-1; i < j; i, j = i+1, j-1 {
+			exp[i], exp[j] = fixtures[j], fixtures[i]
+		}
+
+		if diff := cmp.Diff(exp, got); diff != "" {
+			t.Fatalf("sender requests not equal (-exp, +got):\n%v", diff)
+		}
+	})
+}