test(query): add user.GetByEmail query example to test Scenario API

Author: ar3s3ru

internal/user/user_by_email.go

@@ -0,0 +1,122 @@
+package user
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sync"
+	"time"
+
+	"github.com/google/uuid"
+
+	"github.com/get-eventually/go-eventually/event"
+	"github.com/get-eventually/go-eventually/query"
+	"github.com/get-eventually/go-eventually/version"
+)
+
+// View is a public-facing representation of a User entity.
+// Can be obtained through a Query handler.
+type View struct {
+	ID                  uuid.UUID
+	Email               string
+	FirstName, LastName string
+	BirthDate           time.Time
+
+	Version version.Version // NOTE: used to avoid re-processing of already-processed events.
+}
+
+// ErrNotFound is returned by a Query when a specific User has not been found.
+var ErrNotFound = errors.New("user: not found")
+
+var (
+	_ query.Query                              = GetByEmail("test@email.com")
+	_ query.ProcessorHandler[GetByEmail, View] = new(GetByEmailHandler)
+)
+
+// GetByEmail is a Domain Query that can be used to fetch a specific User given its email.
+type GetByEmail string
+
+// Name implements query.Query.
+func (GetByEmail) Name() string { return "GetUserByEmail" }
+
+// GetByEmailHandler is a stateful Query Handler that maintains a list of Users
+// indexed by their email.
+//
+// It can be used to answer GetByEmail queries.
+//
+// GetByEmailHandler is thread-safe.
+type GetByEmailHandler struct {
+	mx        sync.RWMutex
+	data      map[string]View
+	idToEmail map[uuid.UUID]string
+}
+
+// NewGetByEmailHandler creates a new GetByEmailHandler instance.
+func NewGetByEmailHandler() *GetByEmailHandler {
+	handler := new(GetByEmailHandler)
+	handler.data = make(map[string]View)
+	handler.idToEmail = make(map[uuid.UUID]string)
+
+	return handler
+}
+
+// Handle implements query.Handler.
+func (handler *GetByEmailHandler) Handle(_ context.Context, q query.Envelope[GetByEmail]) (View, error) {
+	handler.mx.RLock()
+	defer handler.mx.RUnlock()
+
+	user, ok := handler.data[string(q.Message)]
+	if !ok {
+		return View{}, fmt.Errorf("user.GetByEmailHandler: failed to get User by email, %w", ErrNotFound)
+	}
+
+	return user, nil
+}
+
+// Process implements event.Processor.
+func (handler *GetByEmailHandler) Process(_ context.Context, evt event.Persisted) error {
+	handler.mx.Lock()
+	defer handler.mx.Unlock()
+
+	userEvent, ok := evt.Envelope.Message.(*Event)
+	if !ok {
+		return fmt.Errorf("user.GetByEmailHandler: unexpected event type, %T", evt.Envelope.Message)
+	}
+
+	switch kind := userEvent.Kind.(type) {
+	case *WasCreated:
+		handler.idToEmail[userEvent.ID] = kind.Email
+		handler.data[kind.Email] = View{
+			ID:        userEvent.ID,
+			Email:     kind.Email,
+			FirstName: kind.FirstName,
+			LastName:  kind.LastName,
+			BirthDate: kind.BirthDate,
+			Version:   evt.Version,
+		}
+
+	case *EmailWasUpdated:
+		previousEmail, ok := handler.idToEmail[userEvent.ID]
+		if !ok {
+			return fmt.Errorf("user.GetByEmailHandler: expected id to have been registered, none found")
+		}
+
+		view, ok := handler.data[previousEmail]
+		if !ok {
+			return fmt.Errorf("user.GetByEmailHandler: expected view to be registered, none found")
+		}
+
+		if view.Version >= evt.Version {
+			return nil
+		}
+
+		view.Email = kind.Email
+		handler.idToEmail[userEvent.ID] = view.Email
+		handler.data[view.Email] = view
+
+	default:
+		return fmt.Errorf("user.GetByEmailHandler: unexpected User event kind, %T", kind)
+	}
+
+	return nil
+}

query/scenario_test.go

@@ -0,0 +1,62 @@
+package query_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/google/uuid"
+
+	"github.com/get-eventually/go-eventually/event"
+	"github.com/get-eventually/go-eventually/internal/user"
+	"github.com/get-eventually/go-eventually/query"
+)
+
+func TestScenario(t *testing.T) {
+	id := uuid.New()
+	now := time.Now()
+	before := now.Add(-1 * time.Minute)
+
+	expected := user.View{
+		ID:        id,
+		Version:   1,
+		Email:     "me@email.com",
+		FirstName: "John",
+		LastName:  "Doe",
+		BirthDate: time.Date(1970, 1, 1, 0, 0, 0, 0, time.UTC),
+	}
+
+	makeQueryHandler := func(es event.Store) *user.GetByEmailHandler {
+		return user.NewGetByEmailHandler()
+	}
+
+	t.Run("returns the expected User by its email when it was just created", func(t *testing.T) {
+		query.
+			Scenario[user.GetByEmail, user.View, *user.GetByEmailHandler]().
+			Given(event.Persisted{
+				StreamID: event.StreamID(id.String()),
+				Version:  1,
+				Envelope: event.ToEnvelope(&user.Event{
+					ID:         id,
+					RecordTime: before,
+					Kind: &user.WasCreated{
+						FirstName: expected.FirstName,
+						LastName:  expected.LastName,
+						BirthDate: expected.BirthDate,
+						Email:     expected.Email,
+					},
+				}),
+			}).
+			When(query.ToEnvelope(user.GetByEmail(expected.Email))).
+			Then(expected).
+			AssertOn(t, makeQueryHandler)
+	})
+
+	t.Run("returns user.ErrNotFound if the requested User does not exist", func(t *testing.T) {
+		query.
+			Scenario[user.GetByEmail, user.View, *user.GetByEmailHandler]().
+			Given().
+			When(query.ToEnvelope(user.GetByEmail(expected.Email))).
+			ThenError(user.ErrNotFound).
+			AssertOn(t, makeQueryHandler)
+	})
+}