chore: move the go code into a subfolder

apps/api/internal/eventstore/repository/mock/gen_mock.go

@@ -0,0 +1,3 @@
+package mock
+
+//go:generate mockgen -package mock -destination ./repository.mock.go github.com/zitadel/zitadel/internal/eventstore Querier,Pusher

apps/api/internal/eventstore/repository/mock/repository.mock.go

@@ -0,0 +1,186 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/zitadel/zitadel/internal/eventstore (interfaces: Querier,Pusher)
+//
+// Generated by this command:
+//
+//	mockgen -package mock -destination ./repository.mock.go github.com/zitadel/zitadel/internal/eventstore Querier,Pusher
+//
+
+// Package mock is a generated GoMock package.
+package mock
+
+import (
+	context "context"
+	reflect "reflect"
+
+	decimal "github.com/shopspring/decimal"
+	database "github.com/zitadel/zitadel/internal/database"
+	eventstore "github.com/zitadel/zitadel/internal/eventstore"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockQuerier is a mock of Querier interface.
+type MockQuerier struct {
+	ctrl     *gomock.Controller
+	recorder *MockQuerierMockRecorder
+}
+
+// MockQuerierMockRecorder is the mock recorder for MockQuerier.
+type MockQuerierMockRecorder struct {
+	mock *MockQuerier
+}
+
+// NewMockQuerier creates a new mock instance.
+func NewMockQuerier(ctrl *gomock.Controller) *MockQuerier {
+	mock := &MockQuerier{ctrl: ctrl}
+	mock.recorder = &MockQuerierMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockQuerier) EXPECT() *MockQuerierMockRecorder {
+	return m.recorder
+}
+
+// Client mocks base method.
+func (m *MockQuerier) Client() *database.DB {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Client")
+	ret0, _ := ret[0].(*database.DB)
+	return ret0
+}
+
+// Client indicates an expected call of Client.
+func (mr *MockQuerierMockRecorder) Client() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Client", reflect.TypeOf((*MockQuerier)(nil).Client))
+}
+
+// FilterToReducer mocks base method.
+func (m *MockQuerier) FilterToReducer(arg0 context.Context, arg1 *eventstore.SearchQueryBuilder, arg2 eventstore.Reducer) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "FilterToReducer", arg0, arg1, arg2)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// FilterToReducer indicates an expected call of FilterToReducer.
+func (mr *MockQuerierMockRecorder) FilterToReducer(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FilterToReducer", reflect.TypeOf((*MockQuerier)(nil).FilterToReducer), arg0, arg1, arg2)
+}
+
+// Health mocks base method.
+func (m *MockQuerier) Health(arg0 context.Context) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Health", arg0)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Health indicates an expected call of Health.
+func (mr *MockQuerierMockRecorder) Health(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Health", reflect.TypeOf((*MockQuerier)(nil).Health), arg0)
+}
+
+// InstanceIDs mocks base method.
+func (m *MockQuerier) InstanceIDs(arg0 context.Context, arg1 *eventstore.SearchQueryBuilder) ([]string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "InstanceIDs", arg0, arg1)
+	ret0, _ := ret[0].([]string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// InstanceIDs indicates an expected call of InstanceIDs.
+func (mr *MockQuerierMockRecorder) InstanceIDs(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDs", reflect.TypeOf((*MockQuerier)(nil).InstanceIDs), arg0, arg1)
+}
+
+// LatestPosition mocks base method.
+func (m *MockQuerier) LatestPosition(arg0 context.Context, arg1 *eventstore.SearchQueryBuilder) (decimal.Decimal, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "LatestPosition", arg0, arg1)
+	ret0, _ := ret[0].(decimal.Decimal)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// LatestPosition indicates an expected call of LatestPosition.
+func (mr *MockQuerierMockRecorder) LatestPosition(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LatestPosition", reflect.TypeOf((*MockQuerier)(nil).LatestPosition), arg0, arg1)
+}
+
+// MockPusher is a mock of Pusher interface.
+type MockPusher struct {
+	ctrl     *gomock.Controller
+	recorder *MockPusherMockRecorder
+}
+
+// MockPusherMockRecorder is the mock recorder for MockPusher.
+type MockPusherMockRecorder struct {
+	mock *MockPusher
+}
+
+// NewMockPusher creates a new mock instance.
+func NewMockPusher(ctrl *gomock.Controller) *MockPusher {
+	mock := &MockPusher{ctrl: ctrl}
+	mock.recorder = &MockPusherMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockPusher) EXPECT() *MockPusherMockRecorder {
+	return m.recorder
+}
+
+// Client mocks base method.
+func (m *MockPusher) Client() *database.DB {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Client")
+	ret0, _ := ret[0].(*database.DB)
+	return ret0
+}
+
+// Client indicates an expected call of Client.
+func (mr *MockPusherMockRecorder) Client() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Client", reflect.TypeOf((*MockPusher)(nil).Client))
+}
+
+// Health mocks base method.
+func (m *MockPusher) Health(arg0 context.Context) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Health", arg0)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Health indicates an expected call of Health.
+func (mr *MockPusherMockRecorder) Health(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Health", reflect.TypeOf((*MockPusher)(nil).Health), arg0)
+}
+
+// Push mocks base method.
+func (m *MockPusher) Push(arg0 context.Context, arg1 database.ContextQueryExecuter, arg2 ...eventstore.Command) ([]eventstore.Event, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "Push", varargs...)
+	ret0, _ := ret[0].([]eventstore.Event)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Push indicates an expected call of Push.
+func (mr *MockPusherMockRecorder) Push(arg0, arg1 any, arg2 ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Push", reflect.TypeOf((*MockPusher)(nil).Push), varargs...)
+}

apps/api/internal/eventstore/repository/mock/repository.mock.impl.go

@@ -0,0 +1,235 @@
+package mock
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/shopspring/decimal"
+	"github.com/stretchr/testify/assert"
+	"go.uber.org/mock/gomock"
+
+	"github.com/zitadel/zitadel/internal/database"
+	"github.com/zitadel/zitadel/internal/eventstore"
+	"github.com/zitadel/zitadel/internal/eventstore/repository"
+)
+
+type MockRepository struct {
+	*MockPusher
+	*MockQuerier
+}
+
+func NewRepo(t *testing.T) *MockRepository {
+	controller := gomock.NewController(t)
+	return &MockRepository{
+		MockPusher:  NewMockPusher(controller),
+		MockQuerier: NewMockQuerier(controller),
+	}
+}
+
+func (m *MockRepository) ExpectFilterNoEventsNoError() *MockRepository {
+	m.MockQuerier.ctrl.T.Helper()
+
+	m.MockQuerier.EXPECT().FilterToReducer(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil)
+	return m
+}
+
+func (m *MockRepository) ExpectFilterEvents(events ...eventstore.Event) *MockRepository {
+	m.MockQuerier.ctrl.T.Helper()
+
+	m.MockQuerier.EXPECT().FilterToReducer(gomock.Any(), gomock.Any(), gomock.Any()).DoAndReturn(
+		func(_ context.Context, _ *eventstore.SearchQueryBuilder, reduce eventstore.Reducer) error {
+			for _, event := range events {
+				if err := reduce(event); err != nil {
+					return err
+				}
+			}
+			return nil
+		},
+	)
+	return m
+}
+
+func (m *MockRepository) ExpectFilterEventsError(err error) *MockRepository {
+	m.MockQuerier.ctrl.T.Helper()
+
+	m.MockQuerier.EXPECT().FilterToReducer(gomock.Any(), gomock.Any(), gomock.Any()).Return(err)
+	return m
+}
+
+func (m *MockRepository) ExpectInstanceIDs(hasFilters []*repository.Filter, instanceIDs ...string) *MockRepository {
+	m.MockQuerier.ctrl.T.Helper()
+
+	matcher := gomock.Any()
+	if len(hasFilters) > 0 {
+		matcher = &filterQueryMatcher{SubQueries: [][]*repository.Filter{hasFilters}}
+	}
+	m.MockQuerier.EXPECT().InstanceIDs(gomock.Any(), matcher).Return(instanceIDs, nil)
+	return m
+}
+
+func (m *MockRepository) ExpectInstanceIDsError(err error) *MockRepository {
+	m.MockQuerier.ctrl.T.Helper()
+
+	m.MockQuerier.EXPECT().InstanceIDs(gomock.Any(), gomock.Any()).Return(nil, err)
+	return m
+}
+
+// ExpectPush checks if the expectedCommands are send to the Push method.
+// The call will sleep at least the amount of passed duration.
+func (m *MockRepository) ExpectPush(expectedCommands []eventstore.Command, sleep time.Duration) *MockRepository {
+	m.MockPusher.EXPECT().Push(gomock.Any(), gomock.Any(), gomock.Any()).DoAndReturn(
+		func(ctx context.Context, _ database.ContextQueryExecuter, commands ...eventstore.Command) ([]eventstore.Event, error) {
+			m.MockPusher.ctrl.T.Helper()
+
+			time.Sleep(sleep)
+
+			if len(expectedCommands) != len(commands) {
+				return nil, fmt.Errorf("unexpected amount of commands: want %d, got %d", len(expectedCommands), len(commands))
+			}
+			for i, expectedCommand := range expectedCommands {
+				if !assert.Equal(m.MockPusher.ctrl.T, expectedCommand.Aggregate(), commands[i].Aggregate()) {
+					m.MockPusher.ctrl.T.Errorf("invalid command.Aggregate [%d]: expected: %#v got: %#v", i, expectedCommand.Aggregate(), commands[i].Aggregate())
+				}
+				if !assert.Equal(m.MockPusher.ctrl.T, expectedCommand.Creator(), commands[i].Creator()) {
+					m.MockPusher.ctrl.T.Errorf("invalid command.Creator [%d]: expected: %#v got: %#v", i, expectedCommand.Creator(), commands[i].Creator())
+				}
+				if !assert.Equal(m.MockPusher.ctrl.T, expectedCommand.Type(), commands[i].Type()) {
+					m.MockPusher.ctrl.T.Errorf("invalid command.Type [%d]: expected: %#v got: %#v", i, expectedCommand.Type(), commands[i].Type())
+				}
+				if !assert.Equal(m.MockPusher.ctrl.T, expectedCommand.Revision(), commands[i].Revision()) {
+					m.MockPusher.ctrl.T.Errorf("invalid command.Revision [%d]: expected: %#v got: %#v", i, expectedCommand.Revision(), commands[i].Revision())
+				}
+
+				var expectedPayload []byte
+				expectedPayload, ok := expectedCommand.Payload().([]byte)
+				if !ok {
+					expectedPayload, _ = json.Marshal(expectedCommand.Payload())
+				}
+				if string(expectedPayload) == "" {
+					expectedPayload = []byte("null")
+				}
+				gotPayload, _ := json.Marshal(commands[i].Payload())
+
+				if !assert.Equal(m.MockPusher.ctrl.T, expectedPayload, gotPayload) {
+					m.MockPusher.ctrl.T.Errorf("invalid command.Payload [%d]: expected: %#v got: %#v", i, expectedCommand.Payload(), commands[i].Payload())
+				}
+				if !assert.ElementsMatch(m.MockPusher.ctrl.T, expectedCommand.UniqueConstraints(), commands[i].UniqueConstraints()) {
+					m.MockPusher.ctrl.T.Errorf("invalid command.UniqueConstraints [%d]: expected: %#v got: %#v", i, expectedCommand.UniqueConstraints(), commands[i].UniqueConstraints())
+				}
+			}
+			events := make([]eventstore.Event, len(commands))
+			for i, command := range commands {
+				events[i] = &mockEvent{
+					Command: command,
+				}
+			}
+			return events, nil
+		},
+	)
+	return m
+}
+
+func (m *MockRepository) ExpectPushFailed(err error, expectedCommands []eventstore.Command) *MockRepository {
+	m.MockPusher.ctrl.T.Helper()
+
+	m.MockPusher.EXPECT().Push(gomock.Any(), gomock.Any(), gomock.Any()).DoAndReturn(
+		func(ctx context.Context, _ database.ContextQueryExecuter, commands ...eventstore.Command) ([]eventstore.Event, error) {
+			if len(expectedCommands) != len(commands) {
+				return nil, fmt.Errorf("unexpected amount of commands: want %d, got %d", len(expectedCommands), len(commands))
+			}
+			for i, expectedCommand := range expectedCommands {
+				assert.Equal(m.MockPusher.ctrl.T, expectedCommand.Aggregate(), commands[i].Aggregate())
+				assert.Equal(m.MockPusher.ctrl.T, expectedCommand.Creator(), commands[i].Creator())
+				assert.Equal(m.MockPusher.ctrl.T, expectedCommand.Type(), commands[i].Type())
+				assert.Equal(m.MockPusher.ctrl.T, expectedCommand.Revision(), commands[i].Revision())
+				var expectedPayload []byte
+				expectedPayload, ok := expectedCommand.Payload().([]byte)
+				if !ok {
+					expectedPayload, _ = json.Marshal(expectedCommand.Payload())
+				}
+				if string(expectedPayload) == "" {
+					expectedPayload = []byte("null")
+				}
+				gotPayload, _ := json.Marshal(commands[i].Payload())
+
+				assert.Equal(m.MockPusher.ctrl.T, expectedPayload, gotPayload)
+				assert.ElementsMatch(m.MockPusher.ctrl.T, expectedCommand.UniqueConstraints(), commands[i].UniqueConstraints())
+			}
+
+			return nil, err
+		},
+	)
+	return m
+}
+
+type mockEvent struct {
+	eventstore.Command
+	sequence  uint64
+	createdAt time.Time
+}
+
+// DataAsBytes implements eventstore.Event
+func (e *mockEvent) DataAsBytes() []byte {
+	if e.Payload() == nil {
+		return nil
+	}
+	payload, err := json.Marshal(e.Payload())
+	if err != nil {
+		panic(err)
+	}
+	return payload
+}
+
+func (e *mockEvent) Unmarshal(ptr any) error {
+	if e.Payload() == nil {
+		return nil
+	}
+	payload, err := json.Marshal(e.Payload())
+	if err != nil {
+		return err
+	}
+	return json.Unmarshal(payload, ptr)
+}
+
+func (e *mockEvent) Sequence() uint64 {
+	return e.sequence
+}
+
+func (e *mockEvent) Position() decimal.Decimal {
+	return decimal.Decimal{}
+}
+
+func (e *mockEvent) CreatedAt() time.Time {
+	return e.createdAt
+}
+
+func (m *MockRepository) ExpectRandomPush(expectedCommands []eventstore.Command) *MockRepository {
+	m.MockPusher.EXPECT().Push(gomock.Any(), gomock.Any(), gomock.Any()).DoAndReturn(
+		func(ctx context.Context, _ database.ContextQueryExecuter, commands ...eventstore.Command) ([]eventstore.Event, error) {
+			assert.Len(m.MockPusher.ctrl.T, commands, len(expectedCommands))
+
+			events := make([]eventstore.Event, len(commands))
+			for i, command := range commands {
+				events[i] = &mockEvent{
+					Command: command,
+				}
+			}
+
+			return events, nil
+		},
+	)
+	return m
+}
+
+func (m *MockRepository) ExpectRandomPushFailed(err error, expectedEvents []eventstore.Command) *MockRepository {
+	m.MockPusher.EXPECT().Push(gomock.Any(), gomock.Any(), gomock.Any()).DoAndReturn(
+		func(ctx context.Context, _ database.ContextQueryExecuter, events ...eventstore.Command) ([]eventstore.Event, error) {
+			assert.Len(m.MockPusher.ctrl.T, events, len(expectedEvents))
+			return nil, err
+		},
+	)
+	return m
+}

apps/api/internal/eventstore/repository/mock/repository.mock.matcher.filter.go

@@ -0,0 +1,33 @@
+package mock
+
+import (
+	"encoding/json"
+	"fmt"
+	"reflect"
+
+	"go.uber.org/mock/gomock"
+
+	"github.com/zitadel/zitadel/internal/eventstore/repository"
+)
+
+var _ gomock.Matcher = (*filterMatcher)(nil)
+var _ gomock.GotFormatter = (*filterMatcher)(nil)
+
+type filterMatcher repository.Filter
+
+func (f *filterMatcher) String() string {
+	jsonValue, err := json.Marshal(f.Value)
+	if err != nil {
+		panic(err)
+	}
+	return fmt.Sprintf("%d %d (content=%+v,type=%T,json=%s)", f.Field, f.Operation, f.Value, f.Value, string(jsonValue))
+}
+
+func (f *filterMatcher) Matches(x interface{}) bool {
+	other := x.(*repository.Filter)
+	return f.Field == other.Field && f.Operation == other.Operation && reflect.DeepEqual(f.Value, other.Value)
+}
+
+func (f *filterMatcher) Got(got interface{}) string {
+	return (*filterMatcher)(got.(*repository.Filter)).String()
+}

apps/api/internal/eventstore/repository/mock/repository.mock.matcher.searchquery.go

@@ -0,0 +1,45 @@
+package mock
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/zitadel/zitadel/internal/eventstore/repository"
+)
+
+type filterQueryMatcher repository.SearchQuery
+
+func (f *filterQueryMatcher) String() string {
+	var filterLists []string
+	for _, filterSlice := range f.SubQueries {
+		var str string
+		for _, filter := range filterSlice {
+			str += "," + (*filterMatcher)(filter).String()
+		}
+		filterLists = append(filterLists, fmt.Sprintf("[%s]", strings.TrimPrefix(str, ",")))
+
+	}
+	return fmt.Sprintf("Filters: %s", strings.Join(filterLists, " "))
+}
+
+func (f *filterQueryMatcher) Matches(x interface{}) bool {
+	other := x.(*repository.SearchQuery)
+	if len(f.SubQueries) != len(other.SubQueries) {
+		return false
+	}
+	for filterSliceIdx, filterSlice := range f.SubQueries {
+		if len(filterSlice) != len(other.SubQueries[filterSliceIdx]) {
+			return false
+		}
+		for filterIdx, filter := range f.SubQueries[filterSliceIdx] {
+			if !(*filterMatcher)(filter).Matches(other.SubQueries[filterSliceIdx][filterIdx]) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+func (f *filterQueryMatcher) Got(got interface{}) string {
+	return (*filterQueryMatcher)(got.(*repository.SearchQuery)).String()
+}