chore: move the go code into a subfolder

apps/api/internal/query/projection/event_test.go

@@ -0,0 +1,108 @@
+package projection
+
+import (
+	"database/sql"
+	"testing"
+	"time"
+
+	"github.com/zitadel/zitadel/internal/eventstore"
+	"github.com/zitadel/zitadel/internal/eventstore/handler/v2"
+	"github.com/zitadel/zitadel/internal/eventstore/repository"
+)
+
+func testEvent(
+	eventType eventstore.EventType,
+	aggregateType eventstore.AggregateType,
+	data []byte,
+	opts ...eventOption,
+) *repository.Event {
+	return timedTestEvent(eventType, aggregateType, data, time.Now(), opts...)
+}
+
+func toSystemEvent(event *repository.Event) *repository.Event {
+	event.EditorUser = "SYSTEM"
+	return event
+}
+
+func timedTestEvent(
+	eventType eventstore.EventType,
+	aggregateType eventstore.AggregateType,
+	data []byte,
+	creationDate time.Time,
+	opts ...eventOption,
+) *repository.Event {
+	e := &repository.Event{
+		Seq:           15,
+		CreationDate:  creationDate,
+		Typ:           eventType,
+		AggregateType: aggregateType,
+		Data:          data,
+		Version:       "v1",
+		AggregateID:   "agg-id",
+		ResourceOwner: sql.NullString{String: "ro-id", Valid: true},
+		InstanceID:    "instance-id",
+		ID:            "event-id",
+		EditorUser:    "editor-user",
+	}
+	for _, opt := range opts {
+		opt(e)
+	}
+	return e
+}
+
+type eventOption func(e *repository.Event)
+
+func withVersion(v eventstore.Version) eventOption {
+	return func(e *repository.Event) {
+		e.Version = v
+	}
+}
+
+func baseEvent(*testing.T) eventstore.Event {
+	return &eventstore.BaseEvent{}
+}
+
+func getEvent(event *repository.Event, mapper func(eventstore.Event) (eventstore.Event, error)) func(t *testing.T) eventstore.Event {
+	return func(t *testing.T) eventstore.Event {
+		e, err := mapper(event)
+		if err != nil {
+			t.Fatalf("mapper failed: %v", err)
+		}
+		return e
+	}
+}
+
+type wantReduce struct {
+	aggregateType eventstore.AggregateType
+	sequence      uint64
+	executer      *testExecuter
+	err           func(error) bool
+}
+
+func assertReduce(t *testing.T, stmt *handler.Statement, err error, projection string, want wantReduce) {
+	t.Helper()
+	if want.err == nil && err != nil {
+		t.Errorf("unexpected error of type %T: %v", err, err)
+		return
+	}
+	if want.err != nil && want.err(err) {
+		return
+	}
+	if stmt.Aggregate.Type != want.aggregateType {
+		t.Errorf("wrong aggregate type: want: %q got: %q", want.aggregateType, stmt.Aggregate.Type)
+	}
+
+	if stmt.Sequence != want.sequence {
+		t.Errorf("wrong sequence: want: %d got: %d", want.sequence, stmt.Sequence)
+	}
+	if stmt.Execute == nil {
+		want.executer.Validate(t)
+		return
+	}
+	err = stmt.Execute(t.Context(), want.executer, projection)
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+
+	want.executer.Validate(t)
+}