TheArchive/zitadel
1
0
Fork 0
mirror of https://github.com/zitadel/zitadel.git synced 2025-08-11 19:07:30 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat: handle instanceID in projections (#3442)

Browse Source 
* feat: handle instanceID in projections

* rename functions

* fix key lock

* fix import
This commit is contained in:
Livio Amstutz
2022-04-19 08:26:12 +02:00
committed by GitHub
parent c25d853820
commit 1305c14e49
120 changed files with 2078 additions and 1209 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
internal/eventstore/v1/models/aggregate_test.go
View File

@@ -190,7 +190,7 @@ func TestAggregate_Validate(t *testing.T) {
resourceOwner: "org",
PreviousSequence: 5,
Precondition: &precondition{
Query: NewSearchQuery().AggregateIDFilter("hodor"),
Query: NewSearchQuery().AddQuery().AggregateIDFilter("hodor").SearchQuery(),
},
Events: []*Event{
{
@@ -240,7 +240,7 @@ func TestAggregate_Validate(t *testing.T) {
PreviousSequence: 5,
Precondition: &precondition{
Validation: func(...*Event) error { return nil },
Query: NewSearchQuery().AggregateIDFilter("hodor"),
Query: NewSearchQuery().AddQuery().AggregateIDFilter("hodor").SearchQuery(),
},
Events: []*Event{
{

1
internal/eventstore/v1/models/operation.go
View File

@@ -7,4 +7,5 @@ const (
Operation_Greater
Operation_Less
Operation_In
Operation_NotIn
)

302
internal/eventstore/v1/models/search_query.go
View File

@@ -9,24 +9,31 @@ import (
)
type SearchQueryFactory struct {
columns Columns
limit uint64
desc bool
aggregateTypes []AggregateType
aggregateIDs []string
sequenceFrom uint64
sequenceTo uint64
eventTypes []EventType
resourceOwner string
instanceID string
creationDate time.Time
columns Columns
limit uint64
desc bool
queries []*query
}
type query struct {
desc bool
aggregateTypes []AggregateType
aggregateIDs []string
sequenceFrom uint64
sequenceTo uint64
eventTypes []EventType
resourceOwner string
instanceID string
ignoredInstanceIDs []string
creationDate time.Time
factory *SearchQueryFactory
}
type searchQuery struct {
Columns Columns
Limit uint64
Desc bool
Filters []*Filter
Filters [][]*Filter
}
type Columns int32
@@ -39,49 +46,55 @@ const (
)
//FactoryFromSearchQuery is deprecated because it's for migration purposes. use NewSearchQueryFactory
func FactoryFromSearchQuery(query *SearchQuery) *SearchQueryFactory {
func FactoryFromSearchQuery(q *SearchQuery) *SearchQueryFactory {
factory := &SearchQueryFactory{
columns: Columns_Event,
desc: query.Desc,
limit: query.Limit,
desc: q.Desc,
limit: q.Limit,
queries: make([]*query, len(q.Queries)),
}
for _, filter := range query.Filters {
switch filter.field {
case Field_AggregateType:
factory = factory.aggregateTypesMig(filter.value.([]AggregateType)...)
case Field_AggregateID:
if aggregateID, ok := filter.value.(string); ok {
factory = factory.AggregateIDs(aggregateID)
} else if aggregateIDs, ok := filter.value.([]string); ok {
factory = factory.AggregateIDs(aggregateIDs...)
for i, qq := range q.Queries {
factory.queries[i] = &query{factory: factory}
for _, filter := range qq.Filters {
switch filter.field {
case Field_AggregateType:
factory.queries[i] = factory.queries[i].aggregateTypesMig(filter.value.([]AggregateType)...)
case Field_AggregateID:
if aggregateID, ok := filter.value.(string); ok {
factory.queries[i] = factory.queries[i].AggregateIDs(aggregateID)
} else if aggregateIDs, ok := filter.value.([]string); ok {
factory.queries[i] = factory.queries[i].AggregateIDs(aggregateIDs...)
}
case Field_LatestSequence:
if filter.operation == Operation_Greater {
factory.queries[i] = factory.queries[i].SequenceGreater(filter.value.(uint64))
} else {
factory.queries[i] = factory.queries[i].SequenceLess(filter.value.(uint64))
}
case Field_ResourceOwner:
factory.queries[i] = factory.queries[i].ResourceOwner(filter.value.(string))
case Field_InstanceID:
if filter.operation == Operation_Equals {
factory.queries[i] = factory.queries[i].InstanceID(filter.value.(string))
} else if filter.operation == Operation_NotIn {
factory.queries[i] = factory.queries[i].IgnoredInstanceIDs(filter.value.([]string)...)
}
case Field_EventType:
factory.queries[i] = factory.queries[i].EventTypes(filter.value.([]EventType)...)
case Field_EditorService, Field_EditorUser:
logging.WithFields("value", filter.value).Panic("field not converted to factory")
case Field_CreationDate:
factory.queries[i] = factory.queries[i].CreationDateNewer(filter.value.(time.Time))
}
case Field_LatestSequence:
if filter.operation == Operation_Greater {
factory = factory.SequenceGreater(filter.value.(uint64))
} else {
factory = factory.SequenceLess(filter.value.(uint64))
}
case Field_ResourceOwner:
factory = factory.ResourceOwner(filter.value.(string))
case Field_InstanceID:
factory = factory.InstanceID(filter.value.(string))
case Field_EventType:
factory = factory.EventTypes(filter.value.([]EventType)...)
case Field_EditorService, Field_EditorUser:
logging.Log("MODEL-Mr0VN").WithField("value", filter.value).Panic("field not converted to factory")
case Field_CreationDate:
factory = factory.CreationDateNewer(filter.value.(time.Time))
}
}
return factory
}
func NewSearchQueryFactory(aggregateTypes ...AggregateType) *SearchQueryFactory {
return &SearchQueryFactory{
aggregateTypes: aggregateTypes,
}
func NewSearchQueryFactory() *SearchQueryFactory {
return &SearchQueryFactory{}
}
func (factory *SearchQueryFactory) Columns(columns Columns) *SearchQueryFactory {
@@ -94,46 +107,6 @@ func (factory *SearchQueryFactory) Limit(limit uint64) *SearchQueryFactory {
return factory
}
func (factory *SearchQueryFactory) SequenceGreater(sequence uint64) *SearchQueryFactory {
factory.sequenceFrom = sequence
return factory
}
func (factory *SearchQueryFactory) SequenceLess(sequence uint64) *SearchQueryFactory {
factory.sequenceTo = sequence
return factory
}
func (factory *SearchQueryFactory) AggregateIDs(ids ...string) *SearchQueryFactory {
factory.aggregateIDs = ids
return factory
}
func (factory *SearchQueryFactory) aggregateTypesMig(types ...AggregateType) *SearchQueryFactory {
factory.aggregateTypes = types
return factory
}
func (factory *SearchQueryFactory) EventTypes(types ...EventType) *SearchQueryFactory {
factory.eventTypes = types
return factory
}
func (factory *SearchQueryFactory) ResourceOwner(resourceOwner string) *SearchQueryFactory {
factory.resourceOwner = resourceOwner
return factory
}
func (factory *SearchQueryFactory) InstanceID(instanceID string) *SearchQueryFactory {
factory.instanceID = instanceID
return factory
}
func (factory *SearchQueryFactory) CreationDateNewer(time time.Time) *SearchQueryFactory {
factory.creationDate = time
return factory
}
func (factory *SearchQueryFactory) OrderDesc() *SearchQueryFactory {
factory.desc = true
return factory
@@ -144,27 +117,89 @@ func (factory *SearchQueryFactory) OrderAsc() *SearchQueryFactory {
return factory
}
func (factory *SearchQueryFactory) AddQuery() *query {
q := &query{factory: factory}
factory.queries = append(factory.queries, q)
return q
}
func (q *query) Factory() *SearchQueryFactory {
return q.factory
}
func (q *query) SequenceGreater(sequence uint64) *query {
q.sequenceFrom = sequence
return q
}
func (q *query) SequenceLess(sequence uint64) *query {
q.sequenceTo = sequence
return q
}
func (q *query) AggregateTypes(types ...AggregateType) *query {
q.aggregateTypes = types
return q
}
func (q *query) AggregateIDs(ids ...string) *query {
q.aggregateIDs = ids
return q
}
func (q *query) aggregateTypesMig(types ...AggregateType) *query {
q.aggregateTypes = types
return q
}
func (q *query) EventTypes(types ...EventType) *query {
q.eventTypes = types
return q
}
func (q *query) ResourceOwner(resourceOwner string) *query {
q.resourceOwner = resourceOwner
return q
}
func (q *query) InstanceID(instanceID string) *query {
q.instanceID = instanceID
return q
}
func (q *query) IgnoredInstanceIDs(instanceIDs ...string) *query {
q.ignoredInstanceIDs = instanceIDs
return q
}
func (q *query) CreationDateNewer(time time.Time) *query {
q.creationDate = time
return q
}
func (factory *SearchQueryFactory) Build() (*searchQuery, error) {
if factory == nil ||
len(factory.aggregateTypes) < 1 ||
len(factory.queries) < 1 ||
(factory.columns < 0 || factory.columns >= columnsCount) {
return nil, errors.ThrowPreconditionFailed(nil, "MODEL-tGAD3", "factory invalid")
}
filters := []*Filter{
factory.aggregateTypeFilter(),
}
filters := make([][]*Filter, len(factory.queries))
for _, f := range []func() *Filter{
factory.aggregateIDFilter,
factory.sequenceFromFilter,
factory.sequenceToFilter,
factory.eventTypeFilter,
factory.resourceOwnerFilter,
factory.instanceIDFilter,
factory.creationDateNewerFilter,
} {
if filter := f(); filter != nil {
filters = append(filters, filter)
for i, query := range factory.queries {
for _, f := range []func() *Filter{
query.aggregateTypeFilter,
query.aggregateIDFilter,
query.sequenceFromFilter,
query.sequenceToFilter,
query.eventTypeFilter,
query.resourceOwnerFilter,
query.instanceIDFilter,
query.ignoredInstanceIDsFilter,
query.creationDateNewerFilter,
} {
if filter := f(); filter != nil {
filters[i] = append(filters[i], filter)
}
}
}
@@ -176,72 +211,79 @@ func (factory *SearchQueryFactory) Build() (*searchQuery, error) {
}, nil
}
func (factory *SearchQueryFactory) aggregateIDFilter() *Filter {
if len(factory.aggregateIDs) < 1 {
func (q *query) aggregateIDFilter() *Filter {
if len(q.aggregateIDs) < 1 {
return nil
}
if len(factory.aggregateIDs) == 1 {
return NewFilter(Field_AggregateID, factory.aggregateIDs[0], Operation_Equals)
if len(q.aggregateIDs) == 1 {
return NewFilter(Field_AggregateID, q.aggregateIDs[0], Operation_Equals)
}
return NewFilter(Field_AggregateID, factory.aggregateIDs, Operation_In)
return NewFilter(Field_AggregateID, q.aggregateIDs, Operation_In)
}
func (factory *SearchQueryFactory) eventTypeFilter() *Filter {
if len(factory.eventTypes) < 1 {
func (q *query) eventTypeFilter() *Filter {
if len(q.eventTypes) < 1 {
return nil
}
if len(factory.eventTypes) == 1 {
return NewFilter(Field_EventType, factory.eventTypes[0], Operation_Equals)
if len(q.eventTypes) == 1 {
return NewFilter(Field_EventType, q.eventTypes[0], Operation_Equals)
}
return NewFilter(Field_EventType, factory.eventTypes, Operation_In)
return NewFilter(Field_EventType, q.eventTypes, Operation_In)
}
func (factory *SearchQueryFactory) aggregateTypeFilter() *Filter {
if len(factory.aggregateTypes) == 1 {
return NewFilter(Field_AggregateType, factory.aggregateTypes[0], Operation_Equals)
func (q *query) aggregateTypeFilter() *Filter {
if len(q.aggregateTypes) == 1 {
return NewFilter(Field_AggregateType, q.aggregateTypes[0], Operation_Equals)
}
return NewFilter(Field_AggregateType, factory.aggregateTypes, Operation_In)
return NewFilter(Field_AggregateType, q.aggregateTypes, Operation_In)
}
func (factory *SearchQueryFactory) sequenceFromFilter() *Filter {
if factory.sequenceFrom == 0 {
func (q *query) sequenceFromFilter() *Filter {
if q.sequenceFrom == 0 {
return nil
}
sortOrder := Operation_Greater
if factory.desc {
if q.factory.desc {
sortOrder = Operation_Less
}
return NewFilter(Field_LatestSequence, factory.sequenceFrom, sortOrder)
return NewFilter(Field_LatestSequence, q.sequenceFrom, sortOrder)
}
func (factory *SearchQueryFactory) sequenceToFilter() *Filter {
if factory.sequenceTo == 0 {
func (q *query) sequenceToFilter() *Filter {
if q.sequenceTo == 0 {
return nil
}
sortOrder := Operation_Less
if factory.desc {
if q.factory.desc {
sortOrder = Operation_Greater
}
return NewFilter(Field_LatestSequence, factory.sequenceTo, sortOrder)
return NewFilter(Field_LatestSequence, q.sequenceTo, sortOrder)
}
func (factory *SearchQueryFactory) resourceOwnerFilter() *Filter {
if factory.resourceOwner == "" {
func (q *query) resourceOwnerFilter() *Filter {
if q.resourceOwner == "" {
return nil
}
return NewFilter(Field_ResourceOwner, factory.resourceOwner, Operation_Equals)
return NewFilter(Field_ResourceOwner, q.resourceOwner, Operation_Equals)
}
func (factory *SearchQueryFactory) instanceIDFilter() *Filter {
if factory.instanceID == "" {
func (q *query) instanceIDFilter() *Filter {
if q.instanceID == "" {
return nil
}
return NewFilter(Field_InstanceID, factory.instanceID, Operation_Equals)
return NewFilter(Field_InstanceID, q.instanceID, Operation_Equals)
}
func (factory *SearchQueryFactory) creationDateNewerFilter() *Filter {
if factory.creationDate.IsZero() {
func (q *query) ignoredInstanceIDsFilter() *Filter {
if len(q.ignoredInstanceIDs) == 0 {
return nil
}
return NewFilter(Field_CreationDate, factory.creationDate, Operation_Greater)
return NewFilter(Field_InstanceID, q.ignoredInstanceIDs, Operation_NotIn)
}
func (q *query) creationDateNewerFilter() *Filter {
if q.creationDate.IsZero() {
return nil
}
return NewFilter(Field_CreationDate, q.creationDate, Operation_Greater)
}

63
internal/eventstore/v1/models/search_query_old.go
View File

@@ -11,15 +11,46 @@ type SearchQuery struct {
Limit uint64
Desc bool
Filters []*Filter
Queries []*Query
}
type Query struct {
searchQuery *SearchQuery
Filters []*Filter
}
//NewSearchQuery is deprecated. Use SearchQueryFactory
func NewSearchQuery() *SearchQuery {
return &SearchQuery{
Filters: make([]*Filter, 0, 4),
Queries: make([]*Query, 0),
}
}
func (q *SearchQuery) AddQuery() *Query {
query := &Query{
searchQuery: q,
}
q.Queries = append(q.Queries, query)
return query
}
//SearchQuery returns the SearchQuery of the sub query
func (q *Query) SearchQuery() *SearchQuery {
return q.searchQuery
}
func (q *Query) setFilter(filter *Filter) *Query {
for i, f := range q.Filters {
if f.field == filter.field && f.field != Field_LatestSequence {
q.Filters[i] = filter
return q
}
}
q.Filters = append(q.Filters, filter)
return q
}
func (q *SearchQuery) SetLimit(limit uint64) *SearchQuery {
q.Limit = limit
return q
@@ -35,23 +66,23 @@ func (q *SearchQuery) OrderAsc() *SearchQuery {
return q
}
func (q *SearchQuery) AggregateIDFilter(id string) *SearchQuery {
func (q *Query) AggregateIDFilter(id string) *Query {
return q.setFilter(NewFilter(Field_AggregateID, id, Operation_Equals))
}
func (q *SearchQuery) AggregateIDsFilter(ids ...string) *SearchQuery {
func (q *Query) AggregateIDsFilter(ids ...string) *Query {
return q.setFilter(NewFilter(Field_AggregateID, ids, Operation_In))
}
func (q *SearchQuery) AggregateTypeFilter(types ...AggregateType) *SearchQuery {
func (q *Query) AggregateTypeFilter(types ...AggregateType) *Query {
return q.setFilter(NewFilter(Field_AggregateType, types, Operation_In))
}
func (q *SearchQuery) EventTypesFilter(types ...EventType) *SearchQuery {
func (q *Query) EventTypesFilter(types ...EventType) *Query {
return q.setFilter(NewFilter(Field_EventType, types, Operation_In))
}
func (q *SearchQuery) LatestSequenceFilter(sequence uint64) *SearchQuery {
func (q *Query) LatestSequenceFilter(sequence uint64) *Query {
if sequence == 0 {
return q
}
@@ -59,21 +90,25 @@ func (q *SearchQuery) LatestSequenceFilter(sequence uint64) *SearchQuery {
return q.setFilter(NewFilter(Field_LatestSequence, sequence, sortOrder))
}
func (q *SearchQuery) SequenceBetween(from, to uint64) *SearchQuery {
func (q *Query) SequenceBetween(from, to uint64) *Query {
q.setFilter(NewFilter(Field_LatestSequence, from, Operation_Greater))
q.setFilter(NewFilter(Field_LatestSequence, to, Operation_Less))
return q
}
func (q *SearchQuery) ResourceOwnerFilter(resourceOwner string) *SearchQuery {
func (q *Query) ResourceOwnerFilter(resourceOwner string) *Query {
return q.setFilter(NewFilter(Field_ResourceOwner, resourceOwner, Operation_Equals))
}
func (q *SearchQuery) InstanceIDFilter(instanceID string) *SearchQuery {
func (q *Query) InstanceIDFilter(instanceID string) *Query {
return q.setFilter(NewFilter(Field_InstanceID, instanceID, Operation_Equals))
}
func (q *SearchQuery) CreationDateNewerFilter(time time.Time) *SearchQuery {
func (q *Query) ExcludedInstanceIDsFilter(instanceIDs ...string) *Query {
return q.setFilter(NewFilter(Field_InstanceID, instanceIDs, Operation_NotIn))
}
func (q *Query) CreationDateNewerFilter(time time.Time) *Query {
return q.setFilter(NewFilter(Field_CreationDate, time, Operation_Greater))
}
@@ -92,12 +127,14 @@ func (q *SearchQuery) Validate() error {
if q == nil {
return errors.ThrowPreconditionFailed(nil, "MODEL-J5xQi", "search query is nil")
}
if len(q.Filters) == 0 {
if len(q.Queries) == 0 {
return errors.ThrowPreconditionFailed(nil, "MODEL-pF3DR", "no filters set")
}
for _, filter := range q.Filters {
if err := filter.Validate(); err != nil {
return err
for _, query := range q.Queries {
for _, filter := range query.Filters {
if err := filter.Validate(); err != nil {
return err
}
}
}

323
internal/eventstore/v1/models/search_query_test.go
View File

@@ -21,31 +21,48 @@ func testSetLimit(limit uint64) func(factory *SearchQueryFactory) *SearchQueryFa
}
}
func testSetSequence(sequence uint64) func(factory *SearchQueryFactory) *SearchQueryFactory {
return func(factory *SearchQueryFactory) *SearchQueryFactory {
factory = factory.SequenceGreater(sequence)
return factory
func testAddQuery(queryFuncs ...func(*query) *query) func(*SearchQueryFactory) *SearchQueryFactory {
return func(builder *SearchQueryFactory) *SearchQueryFactory {
query := builder.AddQuery()
for _, queryFunc := range queryFuncs {
queryFunc(query)
}
return query.Factory()
}
}
func testSetAggregateIDs(aggregateIDs ...string) func(factory *SearchQueryFactory) *SearchQueryFactory {
return func(factory *SearchQueryFactory) *SearchQueryFactory {
factory = factory.AggregateIDs(aggregateIDs...)
return factory
func testSetSequence(sequence uint64) func(*query) *query {
return func(q *query) *query {
q.SequenceGreater(sequence)
return q
}
}
func testSetEventTypes(eventTypes ...EventType) func(factory *SearchQueryFactory) *SearchQueryFactory {
return func(factory *SearchQueryFactory) *SearchQueryFactory {
factory = factory.EventTypes(eventTypes...)
return factory
func testSetAggregateIDs(aggregateIDs ...string) func(*query) *query {
return func(q *query) *query {
q.AggregateIDs(aggregateIDs...)
return q
}
}
func testSetResourceOwner(resourceOwner string) func(factory *SearchQueryFactory) *SearchQueryFactory {
return func(factory *SearchQueryFactory) *SearchQueryFactory {
factory = factory.ResourceOwner(resourceOwner)
return factory
func testSetAggregateTypes(aggregateTypes ...AggregateType) func(*query) *query {
return func(q *query) *query {
q.AggregateTypes(aggregateTypes...)
return q
}
}
func testSetEventTypes(eventTypes ...EventType) func(*query) *query {
return func(q *query) *query {
q.EventTypes(eventTypes...)
return q
}
}
func testSetResourceOwner(resourceOwner string) func(*query) *query {
return func(q *query) *query {
q.ResourceOwner(resourceOwner)
return q
}
}
@@ -60,10 +77,50 @@ func testSetSortOrder(asc bool) func(factory *SearchQueryFactory) *SearchQueryFa
}
}
func assertFactory(t *testing.T, want, got *SearchQueryFactory) {
t.Helper()
if got.columns != want.columns {
t.Errorf("wrong column: got: %v want: %v", got.columns, want.columns)
}
if got.desc != want.desc {
t.Errorf("wrong desc: got: %v want: %v", got.desc, want.desc)
}
if got.limit != want.limit {
t.Errorf("wrong limit: got: %v want: %v", got.limit, want.limit)
}
if len(got.queries) != len(want.queries) {
t.Errorf("wrong length of queries: got: %v want: %v", len(got.queries), len(want.queries))
}
for i, query := range got.queries {
assertQuery(t, i, want.queries[i], query)
}
}
func assertQuery(t *testing.T, i int, want, got *query) {
t.Helper()
if !reflect.DeepEqual(got.aggregateIDs, want.aggregateIDs) {
t.Errorf("wrong aggregateIDs in query %d : got: %v want: %v", i, got.aggregateIDs, want.aggregateIDs)
}
if !reflect.DeepEqual(got.aggregateTypes, want.aggregateTypes) {
t.Errorf("wrong aggregateTypes in query %d : got: %v want: %v", i, got.aggregateTypes, want.aggregateTypes)
}
if got.sequenceFrom != want.sequenceFrom {
t.Errorf("wrong sequenceFrom in query %d : got: %v want: %v", i, got.sequenceFrom, want.sequenceFrom)
}
if got.sequenceTo != want.sequenceTo {
t.Errorf("wrong sequenceTo in query %d : got: %v want: %v", i, got.sequenceTo, want.sequenceTo)
}
if !reflect.DeepEqual(got.eventTypes, want.eventTypes) {
t.Errorf("wrong eventTypes in query %d : got: %v want: %v", i, got.eventTypes, want.eventTypes)
}
}
func TestSearchQueryFactorySetters(t *testing.T) {
type args struct {
aggregateTypes []AggregateType
setters []func(*SearchQueryFactory) *SearchQueryFactory
setters []func(*SearchQueryFactory) *SearchQueryFactory
}
tests := []struct {
name string
@@ -73,11 +130,9 @@ func TestSearchQueryFactorySetters(t *testing.T) {
{
name: "New factory",
args: args{
aggregateTypes: []AggregateType{"user", "org"},
},
res: &SearchQueryFactory{
aggregateTypes: []AggregateType{"user", "org"},
setters: []func(*SearchQueryFactory) *SearchQueryFactory{},
},
res: &SearchQueryFactory{},
},
{
name: "set columns",
@@ -100,69 +155,98 @@ func TestSearchQueryFactorySetters(t *testing.T) {
{
name: "set sequence",
args: args{
setters: []func(*SearchQueryFactory) *SearchQueryFactory{testSetSequence(90)},
setters: []func(*SearchQueryFactory) *SearchQueryFactory{testAddQuery(testSetSequence(90))},
},
res: &SearchQueryFactory{
sequenceFrom: 90,
queries: []*query{
{
sequenceFrom: 90,
},
},
},
},
{
name: "set aggregateTypes",
args: args{
setters: []func(*SearchQueryFactory) *SearchQueryFactory{testAddQuery(testSetAggregateTypes("user", "org"))},
},
res: &SearchQueryFactory{
queries: []*query{
{
aggregateTypes: []AggregateType{"user", "org"},
},
},
},
},
{
name: "set aggregateIDs",
args: args{
setters: []func(*SearchQueryFactory) *SearchQueryFactory{testSetAggregateIDs("1235", "09824")},
setters: []func(*SearchQueryFactory) *SearchQueryFactory{testAddQuery(testSetAggregateIDs("1235", "09824"))},
},
res: &SearchQueryFactory{
aggregateIDs: []string{"1235", "09824"},
queries: []*query{
{
aggregateIDs: []string{"1235", "09824"},
},
},
},
},
{
name: "set eventTypes",
args: args{
setters: []func(*SearchQueryFactory) *SearchQueryFactory{testSetEventTypes("user.created", "user.updated")},
setters: []func(*SearchQueryFactory) *SearchQueryFactory{testAddQuery(testSetEventTypes("user.created", "user.updated"))},
},
res: &SearchQueryFactory{
eventTypes: []EventType{"user.created", "user.updated"},
queries: []*query{
{
eventTypes: []EventType{"user.created", "user.updated"},
},
},
},
},
{
name: "set resource owner",
args: args{
setters: []func(*SearchQueryFactory) *SearchQueryFactory{testSetResourceOwner("hodor")},
setters: []func(*SearchQueryFactory) *SearchQueryFactory{testAddQuery(testSetResourceOwner("hodor"))},
},
res: &SearchQueryFactory{
resourceOwner: "hodor",
queries: []*query{
{
resourceOwner: "hodor",
},
},
},
},
{
name: "default search query",
args: args{
aggregateTypes: []AggregateType{"user"},
setters: []func(*SearchQueryFactory) *SearchQueryFactory{testSetAggregateIDs("1235", "024"), testSetSortOrder(false)},
setters: []func(*SearchQueryFactory) *SearchQueryFactory{testAddQuery(testSetAggregateTypes("user"), testSetAggregateIDs("1235", "024")), testSetSortOrder(false)},
},
res: &SearchQueryFactory{
aggregateTypes: []AggregateType{"user"},
aggregateIDs: []string{"1235", "024"},
desc: true,
desc: true,
queries: []*query{
{
aggregateTypes: []AggregateType{"user"},
aggregateIDs: []string{"1235", "024"},
},
},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
factory := NewSearchQueryFactory(tt.args.aggregateTypes...)
factory := NewSearchQueryFactory()
for _, setter := range tt.args.setters {
factory = setter(factory)
}
if !reflect.DeepEqual(factory, tt.res) {
t.Errorf("NewSearchQueryFactory() = %v, want %v", factory, tt.res)
}
assertFactory(t, tt.res, factory)
})
}
}
func TestSearchQueryFactoryBuild(t *testing.T) {
type args struct {
aggregateTypes []AggregateType
setters []func(*SearchQueryFactory) *SearchQueryFactory
setters []func(*SearchQueryFactory) *SearchQueryFactory
}
type res struct {
isErr func(err error) bool
@@ -176,8 +260,7 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
{
name: "no aggregate types",
args: args{
aggregateTypes: []AggregateType{},
setters: []func(*SearchQueryFactory) *SearchQueryFactory{},
setters: []func(*SearchQueryFactory) *SearchQueryFactory{},
},
res: res{
isErr: errors.IsPreconditionFailed,
@@ -187,9 +270,9 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
{
name: "invalid column (too low)",
args: args{
aggregateTypes: []AggregateType{"user"},
setters: []func(*SearchQueryFactory) *SearchQueryFactory{
testSetColumns(Columns(-1)),
testAddQuery(testSetAggregateTypes("user")),
},
},
res: res{
@@ -199,9 +282,9 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
{
name: "invalid column (too high)",
args: args{
aggregateTypes: []AggregateType{"user"},
setters: []func(*SearchQueryFactory) *SearchQueryFactory{
testSetColumns(columnsCount),
testAddQuery(testSetAggregateTypes("user")),
},
},
res: res{
@@ -211,8 +294,9 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
{
name: "filter aggregate type",
args: args{
aggregateTypes: []AggregateType{"user"},
setters: []func(*SearchQueryFactory) *SearchQueryFactory{},
setters: []func(*SearchQueryFactory) *SearchQueryFactory{
testAddQuery(testSetAggregateTypes("user")),
},
},
res: res{
isErr: nil,
@@ -220,8 +304,10 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
Columns: 0,
Desc: false,
Limit: 0,
Filters: []*Filter{
NewFilter(Field_AggregateType, AggregateType("user"), Operation_Equals),
Filters: [][]*Filter{
{
NewFilter(Field_AggregateType, AggregateType("user"), Operation_Equals),
},
},
},
},
@@ -229,8 +315,9 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
{
name: "filter aggregate types",
args: args{
aggregateTypes: []AggregateType{"user", "org"},
setters: []func(*SearchQueryFactory) *SearchQueryFactory{},
setters: []func(*SearchQueryFactory) *SearchQueryFactory{
testAddQuery(testSetAggregateTypes("user", "org")),
},
},
res: res{
isErr: nil,
@@ -238,8 +325,10 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
Columns: 0,
Desc: false,
Limit: 0,
Filters: []*Filter{
NewFilter(Field_AggregateType, []AggregateType{"user", "org"}, Operation_In),
Filters: [][]*Filter{
{
NewFilter(Field_AggregateType, []AggregateType{"user", "org"}, Operation_In),
},
},
},
},
@@ -247,11 +336,13 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
{
name: "filter aggregate type, limit, desc",
args: args{
aggregateTypes: []AggregateType{"user"},
setters: []func(*SearchQueryFactory) *SearchQueryFactory{
testSetLimit(5),
testSetSortOrder(false),
testSetSequence(100),
testAddQuery(
testSetAggregateTypes("user"),
testSetSequence(100),
),
},
},
res: res{
@@ -260,9 +351,11 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
Columns: 0,
Desc: true,
Limit: 5,
Filters: []*Filter{
NewFilter(Field_AggregateType, AggregateType("user"), Operation_Equals),
NewFilter(Field_LatestSequence, uint64(100), Operation_Less),
Filters: [][]*Filter{
{
NewFilter(Field_AggregateType, AggregateType("user"), Operation_Equals),
NewFilter(Field_LatestSequence, uint64(100), Operation_Less),
},
},
},
},
@@ -270,11 +363,13 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
{
name: "filter aggregate type, limit, asc",
args: args{
aggregateTypes: []AggregateType{"user"},
setters: []func(*SearchQueryFactory) *SearchQueryFactory{
testSetLimit(5),
testSetSortOrder(true),
testSetSequence(100),
testAddQuery(
testSetSequence(100),
testSetAggregateTypes("user"),
),
},
},
res: res{
@@ -283,9 +378,11 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
Columns: 0,
Desc: false,
Limit: 5,
Filters: []*Filter{
NewFilter(Field_AggregateType, AggregateType("user"), Operation_Equals),
NewFilter(Field_LatestSequence, uint64(100), Operation_Greater),
Filters: [][]*Filter{
{
NewFilter(Field_AggregateType, AggregateType("user"), Operation_Equals),
NewFilter(Field_LatestSequence, uint64(100), Operation_Greater),
},
},
},
},
@@ -293,12 +390,14 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
{
name: "filter aggregate type, limit, desc, max event sequence cols",
args: args{
aggregateTypes: []AggregateType{"user"},
setters: []func(*SearchQueryFactory) *SearchQueryFactory{
testSetLimit(5),
testSetSortOrder(false),
testSetSequence(100),
testSetColumns(Columns_Max_Sequence),
testAddQuery(
testSetSequence(100),
testSetAggregateTypes("user"),
),
},
},
res: res{
@@ -307,9 +406,11 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
Columns: Columns_Max_Sequence,
Desc: true,
Limit: 5,
Filters: []*Filter{
NewFilter(Field_AggregateType, AggregateType("user"), Operation_Equals),
NewFilter(Field_LatestSequence, uint64(100), Operation_Less),
Filters: [][]*Filter{
{
NewFilter(Field_AggregateType, AggregateType("user"), Operation_Equals),
NewFilter(Field_LatestSequence, uint64(100), Operation_Less),
},
},
},
},
@@ -317,9 +418,11 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
{
name: "filter aggregate type and aggregate id",
args: args{
aggregateTypes: []AggregateType{"user"},
setters: []func(*SearchQueryFactory) *SearchQueryFactory{
testSetAggregateIDs("1234"),
testAddQuery(
testSetAggregateIDs("1234"),
testSetAggregateTypes("user"),
),
},
},
res: res{
@@ -328,9 +431,11 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
Columns: 0,
Desc: false,
Limit: 0,
Filters: []*Filter{
NewFilter(Field_AggregateType, AggregateType("user"), Operation_Equals),
NewFilter(Field_AggregateID, "1234", Operation_Equals),
Filters: [][]*Filter{
{
NewFilter(Field_AggregateType, AggregateType("user"), Operation_Equals),
NewFilter(Field_AggregateID, "1234", Operation_Equals),
},
},
},
},
@@ -338,9 +443,11 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
{
name: "filter aggregate type and aggregate ids",
args: args{
aggregateTypes: []AggregateType{"user"},
setters: []func(*SearchQueryFactory) *SearchQueryFactory{
testSetAggregateIDs("1234", "0815"),
testAddQuery(
testSetAggregateIDs("1234", "0815"),
testSetAggregateTypes("user"),
),
},
},
res: res{
@@ -349,9 +456,11 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
Columns: 0,
Desc: false,
Limit: 0,
Filters: []*Filter{
NewFilter(Field_AggregateType, AggregateType("user"), Operation_Equals),
NewFilter(Field_AggregateID, []string{"1234", "0815"}, Operation_In),
Filters: [][]*Filter{
{
NewFilter(Field_AggregateType, AggregateType("user"), Operation_Equals),
NewFilter(Field_AggregateID, []string{"1234", "0815"}, Operation_In),
},
},
},
},
@@ -359,9 +468,11 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
{
name: "filter aggregate type and sequence greater",
args: args{
aggregateTypes: []AggregateType{"user"},
setters: []func(*SearchQueryFactory) *SearchQueryFactory{
testSetSequence(8),
testAddQuery(
testSetSequence(8),
testSetAggregateTypes("user"),
),
},
},
res: res{
@@ -370,9 +481,11 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
Columns: 0,
Desc: false,
Limit: 0,
Filters: []*Filter{
NewFilter(Field_AggregateType, AggregateType("user"), Operation_Equals),
NewFilter(Field_LatestSequence, uint64(8), Operation_Greater),
Filters: [][]*Filter{
{
NewFilter(Field_AggregateType, AggregateType("user"), Operation_Equals),
NewFilter(Field_LatestSequence, uint64(8), Operation_Greater),
},
},
},
},
@@ -380,9 +493,11 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
{
name: "filter aggregate type and event type",
args: args{
aggregateTypes: []AggregateType{"user"},
setters: []func(*SearchQueryFactory) *SearchQueryFactory{
testSetEventTypes("user.created"),
testAddQuery(
testSetAggregateTypes("user"),
testSetEventTypes("user.created"),
),
},
},
res: res{
@@ -391,9 +506,11 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
Columns: 0,
Desc: false,
Limit: 0,
Filters: []*Filter{
NewFilter(Field_AggregateType, AggregateType("user"), Operation_Equals),
NewFilter(Field_EventType, EventType("user.created"), Operation_Equals),
Filters: [][]*Filter{
{
NewFilter(Field_AggregateType, AggregateType("user"), Operation_Equals),
NewFilter(Field_EventType, EventType("user.created"), Operation_Equals),
},
},
},
},
@@ -401,9 +518,11 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
{
name: "filter aggregate type and event types",
args: args{
aggregateTypes: []AggregateType{"user"},
setters: []func(*SearchQueryFactory) *SearchQueryFactory{
testSetEventTypes("user.created", "user.changed"),
testAddQuery(
testSetAggregateTypes("user"),
testSetEventTypes("user.created", "user.changed"),
),
},
},
res: res{
@@ -412,9 +531,11 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
Columns: 0,
Desc: false,
Limit: 0,
Filters: []*Filter{
NewFilter(Field_AggregateType, AggregateType("user"), Operation_Equals),
NewFilter(Field_EventType, []EventType{"user.created", "user.changed"}, Operation_In),
Filters: [][]*Filter{
{
NewFilter(Field_AggregateType, AggregateType("user"), Operation_Equals),
NewFilter(Field_EventType, []EventType{"user.created", "user.changed"}, Operation_In),
},
},
},
},
@@ -422,9 +543,11 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
{
name: "filter aggregate type resource owner",
args: args{
aggregateTypes: []AggregateType{"user"},
setters: []func(*SearchQueryFactory) *SearchQueryFactory{
testSetResourceOwner("hodor"),
testAddQuery(
testSetAggregateTypes("user"),
testSetResourceOwner("hodor"),
),
},
},
res: res{
@@ -433,9 +556,11 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
Columns: 0,
Desc: false,
Limit: 0,
Filters: []*Filter{
NewFilter(Field_AggregateType, AggregateType("user"), Operation_Equals),
NewFilter(Field_ResourceOwner, "hodor", Operation_Equals),
Filters: [][]*Filter{
{
NewFilter(Field_AggregateType, AggregateType("user"), Operation_Equals),
NewFilter(Field_ResourceOwner, "hodor", Operation_Equals),
},
},
},
},
@@ -443,7 +568,7 @@ func TestSearchQueryFactoryBuild(t *testing.T) {
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
factory := NewSearchQueryFactory(tt.args.aggregateTypes...)
factory := NewSearchQueryFactory()
for _, f := range tt.args.setters {
factory = f(factory)
}