feat(eventstore): Precondition (#69)

* start org

* refactor(eventstore): filter in sql for querier

* feat(eventstore): Aggregate precondition

preconditions are checked right before insert. Insert is still transaction save

* feat(eventstore): check preconditions in repository

* test(eventstore): test precondition in models

* test(eventstore): precondition-tests

* refactor(eventstore): querier as type

* fix(precondition): rename validation from precondition to validation

* test(eventstore): isErr func instead of wantErr bool

* fix: delete org files

* remove comment

Co-authored-by: Livio Amstutz <livio.a@gmail.com>

internal/eventstore/models/aggregate_test.go

@@ -2,6 +2,8 @@ package models
 
 import (
 	"testing"
+
+	"github.com/caos/zitadel/internal/errors"
 )
 
 func TestAggregate_AppendEvent(t *testing.T) {
@@ -34,17 +36,24 @@ func TestAggregate_AppendEvent(t *testing.T) {
 			wantErr: true,
 		},
 		{
-			name:    "event added",
-			fields:  fields{aggregate: &Aggregate{Events: []*Event{}}},
-			args:    args{typ: "user.deactivated"},
-			want:    &Aggregate{Events: []*Event{&Event{Type: "user.deactivated"}}},
+			name:   "event added",
+			fields: fields{aggregate: &Aggregate{Events: []*Event{}}},
+			args:   args{typ: "user.deactivated"},
+			want: &Aggregate{Events: []*Event{
+				{Type: "user.deactivated"},
+			}},
 			wantErr: false,
 		},
 		{
-			name:    "event added",
-			fields:  fields{aggregate: &Aggregate{Events: []*Event{&Event{}}}},
-			args:    args{typ: "user.deactivated"},
-			want:    &Aggregate{Events: []*Event{&Event{}, &Event{Type: "user.deactivated"}}},
+			name: "event added",
+			fields: fields{aggregate: &Aggregate{Events: []*Event{
+				{},
+			}}},
+			args: args{typ: "user.deactivated"},
+			want: &Aggregate{Events: []*Event{
+				{},
+				{Type: "user.deactivated"},
+			}},
 			wantErr: false,
 		},
 	}
@@ -84,90 +93,218 @@ func TestAggregate_Validate(t *testing.T) {
 			name:    "no id error",
 			wantErr: true,
 			fields: fields{aggregate: &Aggregate{
-				typ:            "user",
-				version:        "v1.0.0",
-				editorService:  "svc",
-				editorUser:     "hodor",
-				resourceOwner:  "org",
-				latestSequence: 5,
-				Events: []*Event{&Event{
-					AggregateType:    "user",
-					AggregateVersion: "v1.0.0",
-					EditorService:    "management",
-					EditorUser:       "hodor",
-					ResourceOwner:    "org",
-					Type:             "born",
-				}},
+				typ:              "user",
+				version:          "v1.0.0",
+				editorService:    "svc",
+				editorUser:       "hodor",
+				resourceOwner:    "org",
+				PreviousSequence: 5,
+				Events: []*Event{
+					{
+						AggregateType:    "user",
+						AggregateVersion: "v1.0.0",
+						EditorService:    "management",
+						EditorUser:       "hodor",
+						ResourceOwner:    "org",
+						Type:             "born",
+					}},
 			}},
 		},
 		{
 			name:    "no type error",
 			wantErr: true,
 			fields: fields{aggregate: &Aggregate{
-				id:             "aggID",
-				version:        "v1.0.0",
-				editorService:  "svc",
-				editorUser:     "hodor",
-				resourceOwner:  "org",
-				latestSequence: 5,
-				Events: []*Event{&Event{
-					AggregateID:      "hodor",
-					AggregateVersion: "v1.0.0",
-					EditorService:    "management",
-					EditorUser:       "hodor",
-					ResourceOwner:    "org",
-					Type:             "born",
-				}},
+				id:               "aggID",
+				version:          "v1.0.0",
+				editorService:    "svc",
+				editorUser:       "hodor",
+				resourceOwner:    "org",
+				PreviousSequence: 5,
+				Events: []*Event{
+					{
+						AggregateID:      "hodor",
+						AggregateVersion: "v1.0.0",
+						EditorService:    "management",
+						EditorUser:       "hodor",
+						ResourceOwner:    "org",
+						Type:             "born",
+					}},
 			}},
 		},
 		{
 			name:    "invalid version error",
 			wantErr: true,
 			fields: fields{aggregate: &Aggregate{
-				id:             "aggID",
-				typ:            "user",
-				editorService:  "svc",
-				editorUser:     "hodor",
-				resourceOwner:  "org",
-				latestSequence: 5,
-				Events: []*Event{&Event{
-					AggregateID:   "hodor",
-					AggregateType: "user",
-					EditorService: "management",
-					EditorUser:    "hodor",
-					ResourceOwner: "org",
-					Type:          "born",
-				}},
+				id:               "aggID",
+				typ:              "user",
+				editorService:    "svc",
+				editorUser:       "hodor",
+				resourceOwner:    "org",
+				PreviousSequence: 5,
+				Events: []*Event{
+					{
+						AggregateID:   "hodor",
+						AggregateType: "user",
+						EditorService: "management",
+						EditorUser:    "hodor",
+						ResourceOwner: "org",
+						Type:          "born",
+					}},
 			}},
 		},
 		{
-			name:    "validation ok",
+			name:    "no query in precondition error",
+			wantErr: true,
+			fields: fields{aggregate: &Aggregate{
+				id:               "aggID",
+				typ:              "user",
+				version:          "v1.0.0",
+				editorService:    "svc",
+				editorUser:       "hodor",
+				resourceOwner:    "org",
+				PreviousSequence: 5,
+				Precondition: &precondition{
+					Validation: func(...*Event) error { return nil },
+				},
+				Events: []*Event{
+					{
+						AggregateID:      "hodor",
+						AggregateType:    "user",
+						AggregateVersion: "v1.0.0",
+						EditorService:    "management",
+						EditorUser:       "hodor",
+						ResourceOwner:    "org",
+						Type:             "born",
+					}},
+			}},
+		},
+		{
+			name:    "no func in precondition error",
+			wantErr: true,
+			fields: fields{aggregate: &Aggregate{
+				id:               "aggID",
+				typ:              "user",
+				version:          "v1.0.0",
+				editorService:    "svc",
+				editorUser:       "hodor",
+				resourceOwner:    "org",
+				PreviousSequence: 5,
+				Precondition: &precondition{
+					Query: NewSearchQuery().AggregateIDFilter("hodor"),
+				},
+				Events: []*Event{
+					{
+						AggregateID:      "hodor",
+						AggregateType:    "user",
+						AggregateVersion: "v1.0.0",
+						EditorService:    "management",
+						EditorUser:       "hodor",
+						ResourceOwner:    "org",
+						Type:             "born",
+					}},
+			}},
+		},
+		{
+			name:    "validation without precondition ok",
 			wantErr: false,
 			fields: fields{aggregate: &Aggregate{
-				id:             "aggID",
-				typ:            "user",
-				version:        "v1.0.0",
-				editorService:  "svc",
-				editorUser:     "hodor",
-				resourceOwner:  "org",
-				latestSequence: 5,
-				Events: []*Event{&Event{
-					AggregateID:      "hodor",
-					AggregateType:    "user",
-					AggregateVersion: "v1.0.0",
-					EditorService:    "management",
-					EditorUser:       "hodor",
-					ResourceOwner:    "org",
-					Type:             "born",
-				}},
+				id:               "aggID",
+				typ:              "user",
+				version:          "v1.0.0",
+				editorService:    "svc",
+				editorUser:       "hodor",
+				resourceOwner:    "org",
+				PreviousSequence: 5,
+				Events: []*Event{
+					{
+						AggregateID:      "hodor",
+						AggregateType:    "user",
+						AggregateVersion: "v1.0.0",
+						EditorService:    "management",
+						EditorUser:       "hodor",
+						ResourceOwner:    "org",
+						Type:             "born",
+					}},
+			}},
+		},
+		{
+			name:    "validation with precondition ok",
+			wantErr: false,
+			fields: fields{aggregate: &Aggregate{
+				id:               "aggID",
+				typ:              "user",
+				version:          "v1.0.0",
+				editorService:    "svc",
+				editorUser:       "hodor",
+				resourceOwner:    "org",
+				PreviousSequence: 5,
+				Precondition: &precondition{
+					Validation: func(...*Event) error { return nil },
+					Query:      NewSearchQuery().AggregateIDFilter("hodor"),
+				},
+				Events: []*Event{
+					{
+						AggregateID:      "hodor",
+						AggregateType:    "user",
+						AggregateVersion: "v1.0.0",
+						EditorService:    "management",
+						EditorUser:       "hodor",
+						ResourceOwner:    "org",
+						Type:             "born",
+					}},
 			}},
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			if err := tt.fields.aggregate.Validate(); (err != nil) != tt.wantErr {
+			err := tt.fields.aggregate.Validate()
+			if (err != nil) != tt.wantErr {
 				t.Errorf("Aggregate.Validate() error = %v, wantErr %v", err, tt.wantErr)
 			}
+			if tt.wantErr && !errors.IsPreconditionFailed(err) {
+				t.Errorf("error must extend precondition failed: %v", err)
+			}
+		})
+	}
+}
+
+func TestAggregate_SetPrecondition(t *testing.T) {
+	type fields struct {
+		aggregate *Aggregate
+	}
+	type args struct {
+		query        *SearchQuery
+		validateFunc func(...*Event) error
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		args   args
+		want   *Aggregate
+	}{
+		{
+			name:   "set precondition",
+			fields: fields{aggregate: &Aggregate{}},
+			args: args{
+				query:        &SearchQuery{},
+				validateFunc: func(...*Event) error { return nil },
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+
+			got := tt.fields.aggregate.SetPrecondition(tt.args.query, tt.args.validateFunc)
+			if got.Precondition == nil {
+				t.Error("precondition must not be nil")
+				t.FailNow()
+			}
+			if got.Precondition.Query == nil {
+				t.Error("query of precondition must not be nil")
+			}
+			if got.Precondition.Validation == nil {
+				t.Error("precondition func must not be nil")
+			}
 		})
 	}
 }