mirror of
https://github.com/zitadel/zitadel.git
synced 2024-12-12 11:04:25 +00:00
913 lines
21 KiB
Go
913 lines
21 KiB
Go
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
|
|
shouldCheckPrevious bool
|
|
data func() interface{}
|
|
}
|
|
|
|
func (e *testEvent) CheckPrevious() bool {
|
|
return e.shouldCheckPrevious
|
|
}
|
|
|
|
func (e *testEvent) EditorService() string {
|
|
return "editorService"
|
|
}
|
|
func (e *testEvent) EditorUser() string {
|
|
return "editorUser"
|
|
}
|
|
func (e *testEvent) Type() EventType {
|
|
return "test.event"
|
|
}
|
|
func (e *testEvent) Data() interface{} {
|
|
return e.data()
|
|
}
|
|
|
|
func (e *testEvent) PreviousSequence() uint64 {
|
|
return 0
|
|
}
|
|
|
|
func testFilterMapper(*repository.Event) (Event, error) {
|
|
return &testEvent{description: "hodor"}, nil
|
|
}
|
|
|
|
func Test_eventstore_RegisterFilterEventMapper(t *testing.T) {
|
|
type fields struct {
|
|
eventMapper map[EventType]eventTypeInterceptors
|
|
}
|
|
type args struct {
|
|
eventType EventType
|
|
mapper func(*repository.Event) (Event, error)
|
|
}
|
|
type res struct {
|
|
event Event
|
|
isErr func(error) bool
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
fields fields
|
|
args args
|
|
res res
|
|
}{
|
|
{
|
|
name: "no event type",
|
|
args: args{
|
|
eventType: "",
|
|
mapper: testFilterMapper,
|
|
},
|
|
fields: fields{
|
|
eventMapper: map[EventType]eventTypeInterceptors{},
|
|
},
|
|
res: res{
|
|
isErr: errors.IsErrorInvalidArgument,
|
|
},
|
|
},
|
|
{
|
|
name: "no event mapper",
|
|
args: args{
|
|
eventType: "event.type",
|
|
mapper: nil,
|
|
},
|
|
fields: fields{
|
|
eventMapper: map[EventType]eventTypeInterceptors{},
|
|
},
|
|
res: res{
|
|
isErr: errors.IsErrorInvalidArgument,
|
|
},
|
|
},
|
|
{
|
|
name: "new interceptor",
|
|
fields: fields{
|
|
eventMapper: map[EventType]eventTypeInterceptors{},
|
|
},
|
|
args: args{
|
|
eventType: "event.type",
|
|
mapper: testFilterMapper,
|
|
},
|
|
res: res{
|
|
event: &testEvent{description: "hodor"},
|
|
},
|
|
},
|
|
{
|
|
name: "existing interceptor new filter mapper",
|
|
fields: fields{
|
|
eventMapper: map[EventType]eventTypeInterceptors{
|
|
"event.type": {},
|
|
},
|
|
},
|
|
args: args{
|
|
eventType: "new.event",
|
|
mapper: testFilterMapper,
|
|
},
|
|
res: res{
|
|
event: &testEvent{description: "hodor"},
|
|
},
|
|
},
|
|
{
|
|
name: "existing interceptor existing filter mapper",
|
|
fields: fields{
|
|
eventMapper: map[EventType]eventTypeInterceptors{
|
|
"event.type": {
|
|
filterMapper: func(*repository.Event) (Event, error) {
|
|
return nil, errors.ThrowUnimplemented(nil, "V2-1qPvn", "unimplemented")
|
|
},
|
|
},
|
|
},
|
|
},
|
|
args: args{
|
|
eventType: "new.event",
|
|
mapper: testFilterMapper,
|
|
},
|
|
res: res{
|
|
event: &testEvent{description: "hodor"},
|
|
},
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
es := &Eventstore{
|
|
eventMapper: tt.fields.eventMapper,
|
|
}
|
|
err := es.RegisterFilterEventMapper(tt.args.eventType, tt.args.mapper)
|
|
if (tt.res.isErr != nil && !tt.res.isErr(err)) || (tt.res.isErr == nil && err != nil) {
|
|
t.Errorf("wrong error got: %v", err)
|
|
return
|
|
}
|
|
if tt.res.isErr != nil {
|
|
return
|
|
}
|
|
|
|
mapper := es.eventMapper[tt.args.eventType]
|
|
event, err := mapper.filterMapper(nil)
|
|
if err != nil {
|
|
t.Errorf("unexpected error %v", err)
|
|
}
|
|
|
|
if !reflect.DeepEqual(tt.res.event, event) {
|
|
t.Errorf("events should be deep equal. \ngot %v\nwant %v", event, tt.res.event)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func Test_eventData(t *testing.T) {
|
|
type args struct {
|
|
event Event
|
|
}
|
|
type res struct {
|
|
jsonText []byte
|
|
wantErr bool
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
args args
|
|
res res
|
|
}{
|
|
{
|
|
name: "data as json bytes",
|
|
args: args{
|
|
event: &testEvent{
|
|
data: func() interface{} {
|
|
return []byte(`{"piff":"paff"}`)
|
|
},
|
|
},
|
|
},
|
|
res: res{
|
|
jsonText: []byte(`{"piff":"paff"}`),
|
|
wantErr: false,
|
|
},
|
|
},
|
|
{
|
|
name: "data as invalid json bytes",
|
|
args: args{
|
|
event: &testEvent{
|
|
data: func() interface{} {
|
|
return []byte(`{"piffpaff"}`)
|
|
},
|
|
},
|
|
},
|
|
res: res{
|
|
jsonText: []byte(nil),
|
|
wantErr: true,
|
|
},
|
|
},
|
|
{
|
|
name: "data as struct",
|
|
args: args{
|
|
event: &testEvent{
|
|
data: func() interface{} {
|
|
return struct {
|
|
Piff string `json:"piff"`
|
|
}{Piff: "paff"}
|
|
},
|
|
},
|
|
},
|
|
res: res{
|
|
jsonText: []byte(`{"piff":"paff"}`),
|
|
wantErr: false,
|
|
},
|
|
},
|
|
{
|
|
name: "data as ptr to struct",
|
|
args: args{
|
|
event: &testEvent{
|
|
data: func() interface{} {
|
|
return &struct {
|
|
Piff string `json:"piff"`
|
|
}{Piff: "paff"}
|
|
},
|
|
},
|
|
},
|
|
res: res{
|
|
jsonText: []byte(`{"piff":"paff"}`),
|
|
wantErr: false,
|
|
},
|
|
},
|
|
{
|
|
name: "no data",
|
|
args: args{
|
|
event: &testEvent{
|
|
data: func() interface{} {
|
|
return nil
|
|
},
|
|
},
|
|
},
|
|
res: res{
|
|
jsonText: []byte(nil),
|
|
wantErr: false,
|
|
},
|
|
},
|
|
{
|
|
name: "invalid because primitive",
|
|
args: args{
|
|
event: &testEvent{
|
|
data: func() interface{} {
|
|
return ""
|
|
},
|
|
},
|
|
},
|
|
res: res{
|
|
jsonText: []byte(nil),
|
|
wantErr: true,
|
|
},
|
|
},
|
|
{
|
|
name: "invalid because pointer to primitive",
|
|
args: args{
|
|
event: &testEvent{
|
|
data: func() interface{} {
|
|
var s string
|
|
return &s
|
|
},
|
|
},
|
|
},
|
|
res: res{
|
|
jsonText: []byte(nil),
|
|
wantErr: true,
|
|
},
|
|
},
|
|
{
|
|
name: "invalid because invalid struct for json",
|
|
args: args{
|
|
event: &testEvent{
|
|
data: func() interface{} {
|
|
return struct {
|
|
Field chan string `json:"field"`
|
|
}{}
|
|
},
|
|
},
|
|
},
|
|
res: res{
|
|
jsonText: []byte(nil),
|
|
wantErr: true,
|
|
},
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got, err := eventData(tt.args.event)
|
|
if (err != nil) != tt.res.wantErr {
|
|
t.Errorf("eventData() error = %v, wantErr %v", err, tt.res.wantErr)
|
|
return
|
|
}
|
|
if !reflect.DeepEqual(got, tt.res.jsonText) {
|
|
t.Errorf("eventData() = %v, want %v", string(got), string(tt.res.jsonText))
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
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)
|
|
}
|
|
}
|