mirror of
https://github.com/zitadel/zitadel.git
synced 2025-11-15 08:04:49 +00:00
test: eventstore
This commit is contained in:
adlerhurst
@@ -1,13 +1,46 @@
|
||||
package eventstore
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"reflect"
|
||||
"sync"
|
||||
"testing"
|
||||
|
||||
"github.com/caos/zitadel/internal/errors"
|
||||
"github.com/caos/zitadel/internal/eventstore/v2/repository"
|
||||
)
|
||||
|
||||
type testAggregate struct {
|
||||
id string
|
||||
events []Event
|
||||
previousSequence uint64
|
||||
}
|
||||
|
||||
func (a *testAggregate) ID() string {
|
||||
return a.id
|
||||
}
|
||||
|
||||
func (a *testAggregate) Type() AggregateType {
|
||||
return "test.aggregate"
|
||||
}
|
||||
|
||||
func (a *testAggregate) Events() []Event {
|
||||
return a.events
|
||||
}
|
||||
|
||||
func (a *testAggregate) ResourceOwner() string {
|
||||
return "ro"
|
||||
}
|
||||
|
||||
func (a *testAggregate) Version() Version {
|
||||
return "v1"
|
||||
}
|
||||
|
||||
func (a *testAggregate) PreviousSequence() uint64 {
|
||||
return a.previousSequence
|
||||
}
|
||||
|
||||
// testEvent implements the Event interface
|
||||
type testEvent struct {
|
||||
description string
|
||||
@@ -306,3 +339,574 @@ func Test_eventData(t *testing.T) {
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestEventstore_aggregatesToEvents(t *testing.T) {
|
||||
type args struct {
|
||||
aggregates []aggregater
|
||||
}
|
||||
type res struct {
|
||||
wantErr bool
|
||||
events []*repository.Event
|
||||
}
|
||||
tests := []struct {
|
||||
name string
|
||||
args args
|
||||
res res
|
||||
}{
|
||||
{
|
||||
name: "one aggregate one event",
|
||||
args: args{
|
||||
aggregates: []aggregater{
|
||||
&testAggregate{
|
||||
id: "1",
|
||||
events: []Event{
|
||||
&testEvent{
|
||||
data: func() interface{} { return nil },
|
||||
shouldCheckPrevious: false,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
res: res{
|
||||
wantErr: false,
|
||||
events: []*repository.Event{
|
||||
{
|
||||
AggregateID: "1",
|
||||
AggregateType: "test.aggregate",
|
||||
CheckPreviousSequence: false,
|
||||
Data: []byte(nil),
|
||||
EditorService: "editorService",
|
||||
EditorUser: "editorUser",
|
||||
ResourceOwner: "ro",
|
||||
Type: "test.event",
|
||||
Version: "v1",
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "one aggregate multiple events",
|
||||
args: args{
|
||||
aggregates: []aggregater{
|
||||
&testAggregate{
|
||||
id: "1",
|
||||
events: []Event{
|
||||
&testEvent{
|
||||
data: func() interface{} { return nil },
|
||||
shouldCheckPrevious: false,
|
||||
},
|
||||
&testEvent{
|
||||
data: func() interface{} { return nil },
|
||||
shouldCheckPrevious: false,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
res: res{
|
||||
wantErr: false,
|
||||
events: linkEvents(
|
||||
&repository.Event{
|
||||
AggregateID: "1",
|
||||
AggregateType: "test.aggregate",
|
||||
CheckPreviousSequence: false,
|
||||
Data: []byte(nil),
|
||||
EditorService: "editorService",
|
||||
EditorUser: "editorUser",
|
||||
ResourceOwner: "ro",
|
||||
Type: "test.event",
|
||||
Version: "v1",
|
||||
},
|
||||
&repository.Event{
|
||||
AggregateID: "1",
|
||||
AggregateType: "test.aggregate",
|
||||
CheckPreviousSequence: false,
|
||||
Data: []byte(nil),
|
||||
EditorService: "editorService",
|
||||
EditorUser: "editorUser",
|
||||
ResourceOwner: "ro",
|
||||
Type: "test.event",
|
||||
Version: "v1",
|
||||
},
|
||||
),
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "invalid data",
|
||||
args: args{
|
||||
aggregates: []aggregater{
|
||||
&testAggregate{
|
||||
id: "1",
|
||||
events: []Event{
|
||||
&testEvent{
|
||||
data: func() interface{} { return `{"data":""` },
|
||||
shouldCheckPrevious: false,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
res: res{
|
||||
wantErr: true,
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "multiple aggregates",
|
||||
args: args{
|
||||
aggregates: []aggregater{
|
||||
&testAggregate{
|
||||
id: "1",
|
||||
events: []Event{
|
||||
&testEvent{
|
||||
data: func() interface{} { return nil },
|
||||
shouldCheckPrevious: false,
|
||||
},
|
||||
&testEvent{
|
||||
data: func() interface{} { return nil },
|
||||
shouldCheckPrevious: false,
|
||||
},
|
||||
},
|
||||
},
|
||||
&testAggregate{
|
||||
id: "2",
|
||||
events: []Event{
|
||||
&testEvent{
|
||||
data: func() interface{} { return nil },
|
||||
shouldCheckPrevious: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
res: res{
|
||||
wantErr: false,
|
||||
events: combineEventLists(
|
||||
linkEvents(
|
||||
&repository.Event{
|
||||
AggregateID: "1",
|
||||
AggregateType: "test.aggregate",
|
||||
CheckPreviousSequence: false,
|
||||
Data: []byte(nil),
|
||||
EditorService: "editorService",
|
||||
EditorUser: "editorUser",
|
||||
ResourceOwner: "ro",
|
||||
Type: "test.event",
|
||||
Version: "v1",
|
||||
},
|
||||
&repository.Event{
|
||||
AggregateID: "1",
|
||||
AggregateType: "test.aggregate",
|
||||
CheckPreviousSequence: false,
|
||||
Data: []byte(nil),
|
||||
EditorService: "editorService",
|
||||
EditorUser: "editorUser",
|
||||
ResourceOwner: "ro",
|
||||
Type: "test.event",
|
||||
Version: "v1",
|
||||
},
|
||||
),
|
||||
[]*repository.Event{
|
||||
{
|
||||
AggregateID: "2",
|
||||
AggregateType: "test.aggregate",
|
||||
CheckPreviousSequence: true,
|
||||
Data: []byte(nil),
|
||||
EditorService: "editorService",
|
||||
EditorUser: "editorUser",
|
||||
ResourceOwner: "ro",
|
||||
Type: "test.event",
|
||||
Version: "v1",
|
||||
},
|
||||
},
|
||||
),
|
||||
},
|
||||
},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
es := &Eventstore{}
|
||||
events, err := es.aggregatesToEvents(tt.args.aggregates)
|
||||
if (err != nil) != tt.res.wantErr {
|
||||
t.Errorf("Eventstore.aggregatesToEvents() error = %v, wantErr %v", err, tt.res.wantErr)
|
||||
return
|
||||
}
|
||||
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
if len(tt.res.events) != len(events) {
|
||||
t.Errorf("length of events unequal want: %d got %d", len(tt.res.events), len(events))
|
||||
return
|
||||
}
|
||||
|
||||
for i := 0; i < len(tt.res.events); i++ {
|
||||
compareEvents(t, tt.res.events[i], events[i])
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
type testRepo struct {
|
||||
events []*repository.Event
|
||||
sequence uint64
|
||||
err error
|
||||
t *testing.T
|
||||
}
|
||||
|
||||
func (repo *testRepo) Health(ctx context.Context) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
func (repo *testRepo) Push(ctx context.Context, events ...*repository.Event) error {
|
||||
if repo.err != nil {
|
||||
return repo.err
|
||||
}
|
||||
|
||||
if len(repo.events) != len(events) {
|
||||
repo.t.Errorf("length of events unequal want: %d got %d", len(repo.events), len(events))
|
||||
return fmt.Errorf("")
|
||||
}
|
||||
|
||||
for i := 0; i < len(repo.events); i++ {
|
||||
compareEvents(repo.t, repo.events[i], events[i])
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (repo *testRepo) Filter(ctx context.Context, searchQuery *repository.SearchQuery) (events []*repository.Event, err error) {
|
||||
if repo.err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return repo.events, nil
|
||||
}
|
||||
|
||||
func (repo *testRepo) LatestSequence(ctx context.Context, queryFactory *repository.SearchQuery) (uint64, error) {
|
||||
if repo.err != nil {
|
||||
return 0, repo.err
|
||||
}
|
||||
return repo.sequence, nil
|
||||
}
|
||||
|
||||
func TestEventstore_Push(t *testing.T) {
|
||||
type args struct {
|
||||
aggregates []aggregater
|
||||
}
|
||||
type fields struct {
|
||||
repo *testRepo
|
||||
eventMapper map[EventType]func(*repository.Event) (Event, error)
|
||||
}
|
||||
type res struct {
|
||||
wantErr bool
|
||||
}
|
||||
tests := []struct {
|
||||
name string
|
||||
args args
|
||||
fields fields
|
||||
res res
|
||||
}{
|
||||
{
|
||||
name: "one aggregate one event",
|
||||
args: args{
|
||||
aggregates: []aggregater{
|
||||
&testAggregate{
|
||||
id: "1",
|
||||
events: []Event{
|
||||
&testEvent{
|
||||
data: func() interface{} { return nil },
|
||||
shouldCheckPrevious: false,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
fields: fields{
|
||||
repo: &testRepo{
|
||||
t: t,
|
||||
events: []*repository.Event{
|
||||
{
|
||||
AggregateID: "1",
|
||||
AggregateType: "test.aggregate",
|
||||
CheckPreviousSequence: false,
|
||||
Data: []byte(nil),
|
||||
EditorService: "editorService",
|
||||
EditorUser: "editorUser",
|
||||
ResourceOwner: "ro",
|
||||
Type: "test.event",
|
||||
Version: "v1",
|
||||
},
|
||||
},
|
||||
},
|
||||
eventMapper: map[EventType]func(*repository.Event) (Event, error){
|
||||
"test.event": func(e *repository.Event) (Event, error) {
|
||||
return &testEvent{}, nil
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "one aggregate multiple events",
|
||||
args: args{
|
||||
aggregates: []aggregater{
|
||||
&testAggregate{
|
||||
id: "1",
|
||||
events: []Event{
|
||||
&testEvent{
|
||||
data: func() interface{} { return nil },
|
||||
shouldCheckPrevious: false,
|
||||
},
|
||||
&testEvent{
|
||||
data: func() interface{} { return nil },
|
||||
shouldCheckPrevious: false,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
fields: fields{
|
||||
repo: &testRepo{
|
||||
t: t,
|
||||
events: linkEvents(
|
||||
&repository.Event{
|
||||
AggregateID: "1",
|
||||
AggregateType: "test.aggregate",
|
||||
CheckPreviousSequence: false,
|
||||
Data: []byte(nil),
|
||||
EditorService: "editorService",
|
||||
EditorUser: "editorUser",
|
||||
ResourceOwner: "ro",
|
||||
Type: "test.event",
|
||||
Version: "v1",
|
||||
},
|
||||
&repository.Event{
|
||||
AggregateID: "1",
|
||||
AggregateType: "test.aggregate",
|
||||
CheckPreviousSequence: false,
|
||||
Data: []byte(nil),
|
||||
EditorService: "editorService",
|
||||
EditorUser: "editorUser",
|
||||
ResourceOwner: "ro",
|
||||
Type: "test.event",
|
||||
Version: "v1",
|
||||
},
|
||||
),
|
||||
},
|
||||
eventMapper: map[EventType]func(*repository.Event) (Event, error){
|
||||
"test.event": func(e *repository.Event) (Event, error) {
|
||||
return &testEvent{}, nil
|
||||
},
|
||||
},
|
||||
},
|
||||
res: res{
|
||||
wantErr: false,
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "multiple aggregates",
|
||||
args: args{
|
||||
aggregates: []aggregater{
|
||||
&testAggregate{
|
||||
id: "1",
|
||||
events: []Event{
|
||||
&testEvent{
|
||||
data: func() interface{} { return nil },
|
||||
shouldCheckPrevious: false,
|
||||
},
|
||||
&testEvent{
|
||||
data: func() interface{} { return nil },
|
||||
shouldCheckPrevious: false,
|
||||
},
|
||||
},
|
||||
},
|
||||
&testAggregate{
|
||||
id: "2",
|
||||
events: []Event{
|
||||
&testEvent{
|
||||
data: func() interface{} { return nil },
|
||||
shouldCheckPrevious: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
fields: fields{
|
||||
repo: &testRepo{
|
||||
t: t,
|
||||
events: combineEventLists(
|
||||
linkEvents(
|
||||
&repository.Event{
|
||||
AggregateID: "1",
|
||||
AggregateType: "test.aggregate",
|
||||
CheckPreviousSequence: false,
|
||||
Data: []byte(nil),
|
||||
EditorService: "editorService",
|
||||
EditorUser: "editorUser",
|
||||
ResourceOwner: "ro",
|
||||
Type: "test.event",
|
||||
Version: "v1",
|
||||
},
|
||||
&repository.Event{
|
||||
AggregateID: "1",
|
||||
AggregateType: "test.aggregate",
|
||||
CheckPreviousSequence: false,
|
||||
Data: []byte(nil),
|
||||
EditorService: "editorService",
|
||||
EditorUser: "editorUser",
|
||||
ResourceOwner: "ro",
|
||||
Type: "test.event",
|
||||
Version: "v1",
|
||||
},
|
||||
),
|
||||
[]*repository.Event{
|
||||
{
|
||||
AggregateID: "2",
|
||||
AggregateType: "test.aggregate",
|
||||
CheckPreviousSequence: true,
|
||||
Data: []byte(nil),
|
||||
EditorService: "editorService",
|
||||
EditorUser: "editorUser",
|
||||
ResourceOwner: "ro",
|
||||
Type: "test.event",
|
||||
Version: "v1",
|
||||
},
|
||||
},
|
||||
),
|
||||
},
|
||||
eventMapper: map[EventType]func(*repository.Event) (Event, error){
|
||||
"test.event": func(e *repository.Event) (Event, error) {
|
||||
return &testEvent{}, nil
|
||||
},
|
||||
},
|
||||
},
|
||||
res: res{
|
||||
wantErr: false,
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "push fails",
|
||||
args: args{
|
||||
aggregates: []aggregater{
|
||||
&testAggregate{
|
||||
id: "1",
|
||||
events: []Event{
|
||||
&testEvent{
|
||||
data: func() interface{} { return nil },
|
||||
shouldCheckPrevious: false,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
fields: fields{
|
||||
repo: &testRepo{
|
||||
t: t,
|
||||
err: errors.ThrowInternal(nil, "V2-qaa4S", "test err"),
|
||||
},
|
||||
},
|
||||
res: res{
|
||||
wantErr: true,
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "aggreagtes to events mapping fails",
|
||||
args: args{
|
||||
aggregates: []aggregater{
|
||||
&testAggregate{
|
||||
id: "1",
|
||||
events: []Event{
|
||||
&testEvent{
|
||||
data: func() interface{} { return `{"data":""` },
|
||||
shouldCheckPrevious: false,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
fields: fields{
|
||||
repo: &testRepo{
|
||||
t: t,
|
||||
err: errors.ThrowInternal(nil, "V2-qaa4S", "test err"),
|
||||
},
|
||||
},
|
||||
res: res{
|
||||
wantErr: true,
|
||||
},
|
||||
},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
es := &Eventstore{
|
||||
repo: tt.fields.repo,
|
||||
interceptorMutex: sync.Mutex{},
|
||||
eventMapper: map[EventType]eventTypeInterceptors{},
|
||||
}
|
||||
for eventType, mapper := range tt.fields.eventMapper {
|
||||
err := es.RegisterFilterEventMapper(eventType, mapper)
|
||||
if err != nil {
|
||||
t.Errorf("register event mapper failed: %v", err)
|
||||
t.FailNow()
|
||||
}
|
||||
}
|
||||
|
||||
_, err := es.PushAggregates(context.Background(), tt.args.aggregates...)
|
||||
if (err != nil) != tt.res.wantErr {
|
||||
t.Errorf("Eventstore.aggregatesToEvents() error = %v, wantErr %v", err, tt.res.wantErr)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func combineEventLists(lists ...[]*repository.Event) []*repository.Event {
|
||||
events := []*repository.Event{}
|
||||
for _, list := range lists {
|
||||
events = append(events, list...)
|
||||
}
|
||||
return events
|
||||
}
|
||||
|
||||
func linkEvents(events ...*repository.Event) []*repository.Event {
|
||||
for i := 1; i < len(events); i++ {
|
||||
events[i].PreviousEvent = events[i-1]
|
||||
}
|
||||
return events
|
||||
}
|
||||
|
||||
func compareEvents(t *testing.T, want, got *repository.Event) {
|
||||
t.Helper()
|
||||
|
||||
if want.AggregateID != got.AggregateID {
|
||||
t.Errorf("wrong aggregateID got %q want %q", want.AggregateID, got.AggregateID)
|
||||
}
|
||||
if want.AggregateType != got.AggregateType {
|
||||
t.Errorf("wrong aggregateType got %q want %q", want.AggregateType, got.AggregateType)
|
||||
}
|
||||
if want.CheckPreviousSequence != got.CheckPreviousSequence {
|
||||
t.Errorf("wrong check previous got %v want %v", want.CheckPreviousSequence, got.CheckPreviousSequence)
|
||||
}
|
||||
if !reflect.DeepEqual(want.Data, got.Data) {
|
||||
t.Errorf("wrong data got %s want %s", string(want.Data), string(got.Data))
|
||||
}
|
||||
if want.EditorService != got.EditorService {
|
||||
t.Errorf("wrong editor service got %q want %q", got.EditorService, want.EditorService)
|
||||
}
|
||||
if want.EditorUser != got.EditorUser {
|
||||
t.Errorf("wrong editor user got %q want %q", got.EditorUser, want.EditorUser)
|
||||
}
|
||||
if want.ResourceOwner != got.ResourceOwner {
|
||||
t.Errorf("wrong resource owner got %q want %q", got.ResourceOwner, want.ResourceOwner)
|
||||
}
|
||||
if want.Type != got.Type {
|
||||
t.Errorf("wrong event type got %q want %q", got.Type, want.Type)
|
||||
}
|
||||
if want.Version != got.Version {
|
||||
t.Errorf("wrong version got %q want %q", got.Version, want.Version)
|
||||
}
|
||||
if (want.PreviousEvent == nil) != (got.PreviousEvent == nil) {
|
||||
t.Errorf("linking failed got was linked: %v want was linked: %v", (got.PreviousEvent != nil), (want.PreviousEvent != nil))
|
||||
}
|
||||
if want.PreviousSequence != got.PreviousSequence {
|
||||
t.Errorf("wrong previous sequence got %d want %d", got.PreviousSequence, want.PreviousSequence)
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user