Merge pull request #33 from opencloud-eu/fix-pb-tests

Fix tests

services/notifications/pkg/service/filter_test.go

@@ -2,79 +2,90 @@ package service
 
 import (
 	"context"
-	"testing"
 
 	user "github.com/cs3org/go-cs3apis/cs3/identity/user/v1beta1"
 	"github.com/opencloud-eu/opencloud/pkg/log"
 	settingsmsg "github.com/opencloud-eu/opencloud/protogen/gen/opencloud/messages/settings/v0"
 	settings "github.com/opencloud-eu/opencloud/protogen/gen/opencloud/services/settings/v0"
+	settingsmocks "github.com/opencloud-eu/opencloud/protogen/gen/opencloud/services/settings/v0/mocks"
 	"github.com/pkg/errors"
-	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
-	"go-micro.dev/v4/client"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
 )
 
-var testLogger = log.NewLogger()
+var _ = Describe("NotificationFilter", func() {
+	var (
+		testLogger = log.NewLogger()
+		vs         = &settingsmocks.ValueService{}
+	)
 
-func TestNotificationFilter_execute(t *testing.T) {
+	setupMockValueService := func(mail bool) *settingsmocks.ValueService {
-	type args struct {
+		m := &settingsmocks.ValueService{}
-		ctx       context.Context
+		m.On("GetValueByUniqueIdentifiers", mock.Anything, mock.Anything).Return(&settings.GetValueResponse{
-		users     []*user.User
+			Value: &settingsmsg.ValueWithIdentifier{
-		settingId string
+				Value: &settingsmsg.Value{
-	}
+					Value: &settingsmsg.Value_CollectionValue{
-	tests := []struct {
+						CollectionValue: &settingsmsg.CollectionValue{
-		name string
+							Values: []*settingsmsg.CollectionOption{
-		vc   settings.ValueService
+								{
-		args args
+									Key:    "mail",
-		want []*user.User
+									Option: &settingsmsg.CollectionOption_BoolValue{BoolValue: mail},
-	}{
-		{"no connection to ValueService", settings.MockValueService{
-			GetValueByUniqueIdentifiersFunc: func(ctx context.Context, req *settings.GetValueByUniqueIdentifiersRequest, opts ...client.CallOption) (*settings.GetValueResponse, error) {
-				return nil, errors.New("no connection to ValueService")
-			},
-		}, args{users: []*user.User{{Id: &user.UserId{OpaqueId: "foo"}}}, settingId: "bar", ctx: context.TODO()}, []*user.User{{Id: &user.UserId{OpaqueId: "foo"}}}},
-		{"no setting in ValueService response", settings.MockValueService{
-			GetValueByUniqueIdentifiersFunc: func(ctx context.Context, req *settings.GetValueByUniqueIdentifiersRequest, opts ...client.CallOption) (*settings.GetValueResponse, error) {
-				return &settings.GetValueResponse{}, nil
-			},
-		}, args{users: []*user.User{{Id: &user.UserId{OpaqueId: "foo"}}}, settingId: "bar", ctx: context.TODO()}, []*user.User{{Id: &user.UserId{OpaqueId: "foo"}}}},
-		{"ValueService nil response", settings.MockValueService{
-			GetValueByUniqueIdentifiersFunc: func(ctx context.Context, req *settings.GetValueByUniqueIdentifiersRequest, opts ...client.CallOption) (*settings.GetValueResponse, error) {
-				return nil, nil
-			},
-		}, args{users: []*user.User{{Id: &user.UserId{OpaqueId: "foo"}}}, settingId: "bar", ctx: context.TODO()}, []*user.User{{Id: &user.UserId{OpaqueId: "foo"}}}},
-		{"Event enabled", setupMockValueService(true), args{users: []*user.User{{Id: &user.UserId{OpaqueId: "foo"}}}, settingId: "bar", ctx: context.TODO()}, []*user.User{{Id: &user.UserId{OpaqueId: "foo"}}}},
-		{"Event disabled", setupMockValueService(false), args{users: []*user.User{{Id: &user.UserId{OpaqueId: "foo"}}}, settingId: "bar", ctx: context.TODO()}, []*user.User(nil)},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			ulf := notificationFilter{
-				log:         testLogger,
-				valueClient: tt.vc,
-			}
-			assert.Equal(t, tt.want, ulf.execute(tt.args.ctx, tt.args.users, tt.args.settingId))
-		})
-	}
-}
-
-func setupMockValueService(mail bool) settings.ValueService {
-	return settings.MockValueService{
-		GetValueByUniqueIdentifiersFunc: func(ctx context.Context, req *settings.GetValueByUniqueIdentifiersRequest, opts ...client.CallOption) (*settings.GetValueResponse, error) {
-			return &settings.GetValueResponse{
-				Value: &settingsmsg.ValueWithIdentifier{
-					Value: &settingsmsg.Value{
-						Value: &settingsmsg.Value_CollectionValue{
-							CollectionValue: &settingsmsg.CollectionValue{
-								Values: []*settingsmsg.CollectionOption{
-									{
-										Key:    "mail",
-										Option: &settingsmsg.CollectionOption_BoolValue{BoolValue: mail},
-									},
 								},
 							},
 						},
 					},
 				},
-			}, nil
+			},
-		},
+		}, nil)
+		return m
 	}
-}
+
+	Describe("execute", func() {
+		It("handles connection errors", func() {
+			vs.On("GetValueByUniqueIdentifiers", mock.Anything, mock.Anything).Return(nil, errors.New("no connection to ValueService"))
+			ulf := notificationFilter{
+				log:         testLogger,
+				valueClient: vs,
+			}
+			Expect(ulf.execute(context.TODO(), []*user.User{{Id: &user.UserId{OpaqueId: "foo"}}}, "bar")).To(ConsistOf(&user.User{Id: &user.UserId{OpaqueId: "foo"}}))
+		})
+
+		It("handles no setting in ValueService response", func() {
+			vs.On("GetValueByUniqueIdentifiers", mock.Anything, mock.Anything).Return(&settings.GetValueResponse{}, nil)
+			ulf := notificationFilter{
+				log:         testLogger,
+				valueClient: vs,
+			}
+			Expect(ulf.execute(context.TODO(), []*user.User{{Id: &user.UserId{OpaqueId: "foo"}}}, "bar")).To(ConsistOf(&user.User{Id: &user.UserId{OpaqueId: "foo"}}))
+		})
+
+		It("handles nil responses", func() {
+			vs.On("GetValueByUniqueIdentifiers", mock.Anything, mock.Anything).Return(nil, nil)
+			ulf := notificationFilter{
+				log:         testLogger,
+				valueClient: vs,
+			}
+			Expect(ulf.execute(context.TODO(), []*user.User{{Id: &user.UserId{OpaqueId: "foo"}}}, "bar")).To(ConsistOf(&user.User{Id: &user.UserId{OpaqueId: "foo"}}))
+		})
+
+		It("return users when events are enabled", func() {
+			vs = setupMockValueService(true)
+			ulf := notificationFilter{
+				log:         testLogger,
+				valueClient: vs,
+			}
+			Expect(ulf.execute(context.TODO(), []*user.User{{Id: &user.UserId{OpaqueId: "foo"}}}, "bar")).To(ConsistOf(&user.User{Id: &user.UserId{OpaqueId: "foo"}}))
+		})
+
+		It("return no users when events are disabled", func() {
+			vs = setupMockValueService(false)
+			ulf := notificationFilter{
+				log:         testLogger,
+				valueClient: vs,
+			}
+			Expect(ulf.execute(context.TODO(), []*user.User{{Id: &user.UserId{OpaqueId: "foo"}}}, "bar")).To(BeEmpty())
+		})
+	})
+})

services/notifications/pkg/service/service_test.go

@@ -20,11 +20,11 @@ import (
 	"github.com/opencloud-eu/opencloud/pkg/log"
 	"github.com/opencloud-eu/opencloud/pkg/shared"
 	settingssvc "github.com/opencloud-eu/opencloud/protogen/gen/opencloud/services/settings/v0"
+	settingsmocks "github.com/opencloud-eu/opencloud/protogen/gen/opencloud/services/settings/v0/mocks"
 	"github.com/opencloud-eu/opencloud/services/graph/pkg/config/defaults"
 	"github.com/opencloud-eu/opencloud/services/notifications/pkg/channels"
 	"github.com/opencloud-eu/opencloud/services/notifications/pkg/service"
 	"github.com/stretchr/testify/mock"
-	"go-micro.dev/v4/client"
 	"google.golang.org/grpc"
 )
 
@@ -32,7 +32,7 @@ var _ = Describe("Notifications", func() {
 	var (
 		gatewayClient   *cs3mocks.GatewayAPIClient
 		gatewaySelector pool.Selectable[gateway.GatewayAPIClient]
-		vs              *settingssvc.MockValueService
+		vs              *settingsmocks.ValueService
 		sharer          = &user.User{
 			Id: &user.UserId{
 				OpaqueId: "sharer",
@@ -69,25 +69,23 @@ var _ = Describe("Notifications", func() {
 		gatewayClient.On("GetUser", mock.Anything, mock.Anything).Return(&user.GetUserResponse{Status: &rpc.Status{Code: rpc.Code_CODE_OK}, User: sharee}, nil).Once()
 		gatewayClient.On("Authenticate", mock.Anything, mock.Anything).Return(&gateway.AuthenticateResponse{Status: &rpc.Status{Code: rpc.Code_CODE_OK}, User: sharer}, nil)
 		gatewayClient.On("Stat", mock.Anything, mock.Anything).Return(&provider.StatResponse{Status: &rpc.Status{Code: rpc.Code_CODE_OK}, Info: &provider.ResourceInfo{Name: "secrets of the board", Space: &provider.StorageSpace{Name: "secret space"}}}, nil)
-		vs = &settingssvc.MockValueService{}
+		vs = &settingsmocks.ValueService{}
-		vs.GetValueByUniqueIdentifiersFunc = func(ctx context.Context, req *settingssvc.GetValueByUniqueIdentifiersRequest, opts ...client.CallOption) (*settingssvc.GetValueResponse, error) {
+		vs.On("GetValueByUniqueIdentifiers", mock.Anything, mock.Anything).Return(&settingssvc.GetValueResponse{
-			return &settingssvc.GetValueResponse{
+			Value: &settingsmsg.ValueWithIdentifier{
-				Value: &settingsmsg.ValueWithIdentifier{
+				Value: &settingsmsg.Value{
-					Value: &settingsmsg.Value{
+					Value: &settingsmsg.Value_CollectionValue{
-						Value: &settingsmsg.Value_CollectionValue{
+						CollectionValue: &settingsmsg.CollectionValue{
-							CollectionValue: &settingsmsg.CollectionValue{
+							Values: []*settingsmsg.CollectionOption{
-								Values: []*settingsmsg.CollectionOption{
+								{
-									{
+									Key:    "mail",
-										Key:    "mail",
+									Option: &settingsmsg.CollectionOption_BoolValue{BoolValue: true},
-										Option: &settingsmsg.CollectionOption_BoolValue{BoolValue: true},
-									},
 								},
 							},
 						},
 					},
 				},
-			}, nil
+			},
-		}
+		}, nil)
 	})
 
 	DescribeTable("Sending userEventIds",
@@ -242,7 +240,7 @@ var _ = Describe("Notifications X-Site Scripting", func() {
 	var (
 		gatewayClient   *cs3mocks.GatewayAPIClient
 		gatewaySelector pool.Selectable[gateway.GatewayAPIClient]
-		vs              *settingssvc.MockValueService
+		vs              *settingsmocks.ValueService
 		sharer          = &user.User{
 			Id: &user.UserId{
 				OpaqueId: "sharer",
@@ -284,25 +282,23 @@ var _ = Describe("Notifications X-Site Scripting", func() {
 				Name:  "<script>alert('secrets of the board');</script>",
 				Space: &provider.StorageSpace{Name: "<script>alert('secret space');</script>"}},
 		}, nil)
-		vs = &settingssvc.MockValueService{}
+		vs = &settingsmocks.ValueService{}
-		vs.GetValueByUniqueIdentifiersFunc = func(ctx context.Context, req *settingssvc.GetValueByUniqueIdentifiersRequest, opts ...client.CallOption) (*settingssvc.GetValueResponse, error) {
+		vs.On("GetValueByUniqueIdentifiers", mock.Anything, mock.Anything).Return(&settingssvc.GetValueResponse{
-			return &settingssvc.GetValueResponse{
+			Value: &settingsmsg.ValueWithIdentifier{
-				Value: &settingsmsg.ValueWithIdentifier{
+				Value: &settingsmsg.Value{
-					Value: &settingsmsg.Value{
+					Value: &settingsmsg.Value_CollectionValue{
-						Value: &settingsmsg.Value_CollectionValue{
+						CollectionValue: &settingsmsg.CollectionValue{
-							CollectionValue: &settingsmsg.CollectionValue{
+							Values: []*settingsmsg.CollectionOption{
-								Values: []*settingsmsg.CollectionOption{
+								{
-									{
+									Key:    "mail",
-										Key:    "mail",
+									Option: &settingsmsg.CollectionOption_BoolValue{BoolValue: true},
-										Option: &settingsmsg.CollectionOption_BoolValue{BoolValue: true},
-									},
 								},
 							},
 						},
 					},
 				},
-			}, nil
+			},
-		}
+		}, nil)
 	})
 
 	DescribeTable("Sending userEventIds",

services/notifications/pkg/service/splitter_test.go

@@ -3,180 +3,129 @@ package service
 import (
 	"context"
 	"strings"
-	"testing"
 
 	user "github.com/cs3org/go-cs3apis/cs3/identity/user/v1beta1"
+	"github.com/pkg/errors"
+	"github.com/stretchr/testify/mock"
+	"go-micro.dev/v4/client"
+
 	"github.com/opencloud-eu/opencloud/pkg/log"
 	settingsmsg "github.com/opencloud-eu/opencloud/protogen/gen/opencloud/messages/settings/v0"
 	settings "github.com/opencloud-eu/opencloud/protogen/gen/opencloud/services/settings/v0"
-	v0 "github.com/opencloud-eu/opencloud/protogen/gen/opencloud/services/settings/v0"
+	settingsmocks "github.com/opencloud-eu/opencloud/protogen/gen/opencloud/services/settings/v0/mocks"
-	"github.com/pkg/errors"
+
-	"github.com/stretchr/testify/assert"
+	. "github.com/onsi/ginkgo/v2"
-	"go-micro.dev/v4/client"
+	. "github.com/onsi/gomega"
 )
 
-func Test_intervalSplitter_execute(t *testing.T) {
+var _ = Describe("NotificationFilter", func() {
-	type fields struct {
+	var (
-		log         log.Logger
+		testLogger = log.NewLogger()
-		valueClient v0.ValueService
-	}
-	type args struct {
-		ctx       context.Context
-		users     []*user.User
-		settingId string
-	}
-	tests := []struct {
-		name        string
-		fields      fields
-		args        args
-		wantInstant []*user.User
-		wantDaily   []*user.User
-		wantWeekly  []*user.User
-	}{
-		{"no connection to ValueService",
-			fields{
-				log: testLogger,
-				valueClient: settings.MockValueService{
-					GetValueByUniqueIdentifiersFunc: func(ctx context.Context, req *settings.GetValueByUniqueIdentifiersRequest, opts ...client.CallOption) (*settings.GetValueResponse, error) {
-						return nil, errors.New("no connection to ValueService")
-					}}}, args{
-				ctx:       context.TODO(),
-				users:     newUsers("foo"),
-				settingId: "",
-			},
-			newUsers("foo"), []*user.User(nil), []*user.User(nil),
-		},
-		{"no setting in ValueService response",
-			fields{
-				log: testLogger,
-				valueClient: settings.MockValueService{
-					GetValueByUniqueIdentifiersFunc: func(ctx context.Context, req *settings.GetValueByUniqueIdentifiersRequest, opts ...client.CallOption) (*settings.GetValueResponse, error) {
-						return &settings.GetValueResponse{}, nil
-					}}},
-			args{
-				ctx:       context.TODO(),
-				users:     newUsers("foo"),
-				settingId: "",
-			},
-			newUsers("foo"), []*user.User(nil), []*user.User(nil),
-		},
-		{"ValueService nil response",
-			fields{
-				log: testLogger,
-				valueClient: settings.MockValueService{
-					GetValueByUniqueIdentifiersFunc: func(ctx context.Context, req *settings.GetValueByUniqueIdentifiersRequest, opts ...client.CallOption) (*settings.GetValueResponse, error) {
-						return nil, nil
-					}}},
-			args{
-				ctx:       context.TODO(),
-				users:     newUsers("foo"),
-				settingId: "",
-			},
-			newUsers("foo"), []*user.User(nil), []*user.User(nil),
-		},
-		{"input users nil",
-			fields{
-				log: testLogger,
-				valueClient: settings.MockValueService{
-					GetValueByUniqueIdentifiersFunc: func(ctx context.Context, req *settings.GetValueByUniqueIdentifiersRequest, opts ...client.CallOption) (*settings.GetValueResponse, error) {
-						return nil, nil
-					}},
-			},
-			args{
-				ctx:   context.TODO(),
-				users: nil,
-			},
-			[]*user.User(nil), []*user.User(nil), []*user.User(nil),
-		},
-		{"interval never",
-			fields{
-				log:         testLogger,
-				valueClient: newStringValueMockValueService("never"),
-			},
-			args{
-				ctx:   context.TODO(),
-				users: newUsers("foo"),
-			},
-			[]*user.User(nil), []*user.User(nil), []*user.User(nil),
-		},
-		{"interval instant",
-			fields{
-				log:         testLogger,
-				valueClient: newStringValueMockValueService("instant"),
-			},
-			args{
-				ctx:   context.TODO(),
-				users: newUsers("foo"),
-			},
-			newUsers("foo"), []*user.User(nil), []*user.User(nil),
-		},
-		{"interval daily",
-			fields{
-				log:         testLogger,
-				valueClient: newStringValueMockValueService("daily"),
-			},
-			args{
-				ctx:   context.TODO(),
-				users: newUsers("foo"),
-			},
-			[]*user.User(nil), newUsers("foo"), []*user.User(nil),
-		},
-		{"interval weekly",
-			fields{
-				log:         testLogger,
-				valueClient: newStringValueMockValueService("weekly"),
-			},
-			args{
-				ctx:   context.TODO(),
-				users: newUsers("foo"),
-			},
-			[]*user.User(nil), []*user.User(nil), newUsers("foo"),
-		},
-		{"multiple users and intervals",
-			fields{
-				log: testLogger,
-				valueClient: settings.MockValueService{
-					GetValueByUniqueIdentifiersFunc: func(ctx context.Context, req *settings.GetValueByUniqueIdentifiersRequest, opts ...client.CallOption) (*settings.GetValueResponse, error) {
-						if strings.Contains(req.AccountUuid, "never") {
-							return newGetValueResponseStringValue("never"), nil
-						} else if strings.Contains(req.AccountUuid, "instant") {
-							return newGetValueResponseStringValue("instant"), nil
-						} else if strings.Contains(req.AccountUuid, "daily") {
-							return newGetValueResponseStringValue("daily"), nil
-						} else if strings.Contains(req.AccountUuid, "weekly") {
-							return newGetValueResponseStringValue("weekly"), nil
-						}
-						return nil, nil
-					}},
-			},
-			args{
-				ctx:   context.TODO(),
-				users: newUsers("never1", "instant1", "daily1", "weekly1", "never2", "instant2", "daily2", "weekly2"),
-			},
-			newUsers("instant1", "instant2"), newUsers("daily1", "daily2"), newUsers("weekly1", "weekly2"),
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			s := intervalSplitter{
-				log:         tt.fields.log,
-				valueClient: tt.fields.valueClient,
-			}
-			gotInstant, gotDaily, gotWeekly := s.execute(tt.args.ctx, tt.args.users)
-			assert.Equalf(t, tt.wantInstant, gotInstant, "execute(%v, %v, %v)", tt.args.ctx, tt.args.users)
-			assert.Equalf(t, tt.wantDaily, gotDaily, "execute(%v, %v, %v)", tt.args.ctx, tt.args.users)
-			assert.Equalf(t, tt.wantWeekly, gotWeekly, "execute(%v, %v, %v)", tt.args.ctx, tt.args.users)
-		})
-	}
-}
 
-func newStringValueMockValueService(strVal string) settings.ValueService {
+		vs *settingsmocks.ValueService
-	return settings.MockValueService{
+		s  intervalSplitter
-		GetValueByUniqueIdentifiersFunc: func(ctx context.Context, req *settings.GetValueByUniqueIdentifiersRequest, opts ...client.CallOption) (*settings.GetValueResponse, error) {
+	)
-			return newGetValueResponseStringValue(strVal), nil
+
-		},
+	BeforeEach(func() {
-	}
+		vs = &settingsmocks.ValueService{}
-}
+		s = intervalSplitter{
+			log:         testLogger,
+			valueClient: vs,
+		}
+	})
+
+	It("handles connection errors", func() {
+		vs.On("GetValueByUniqueIdentifiers", mock.Anything, mock.Anything).Return(nil, errors.New("no connection to ValueService"))
+
+		instant, daily, weekly := s.execute(context.TODO(), newUsers("foo"))
+		Expect(instant).To(Equal(newUsers("foo")))
+		Expect(daily).To(BeEmpty())
+		Expect(weekly).To(BeEmpty())
+	})
+
+	It("handles no setting in ValueService response", func() {
+		vs.On("GetValueByUniqueIdentifiers", mock.Anything, mock.Anything).Return(&settings.GetValueResponse{}, nil)
+
+		instant, daily, weekly := s.execute(context.TODO(), newUsers("foo"))
+		Expect(instant).To(Equal(newUsers("foo")))
+		Expect(daily).To(BeEmpty())
+		Expect(weekly).To(BeEmpty())
+	})
+
+	It("handles nil response", func() {
+		vs.On("GetValueByUniqueIdentifiers", mock.Anything, mock.Anything).Return(nil, nil)
+
+		instant, daily, weekly := s.execute(context.TODO(), newUsers("foo"))
+		Expect(instant).To(Equal(newUsers("foo")))
+		Expect(daily).To(BeEmpty())
+		Expect(weekly).To(BeEmpty())
+	})
+
+	It("handles nil input user", func() {
+		vs.On("GetValueByUniqueIdentifiers", mock.Anything, mock.Anything).Return(nil, nil)
+
+		instant, daily, weekly := s.execute(context.TODO(), nil)
+		Expect(instant).To(BeEmpty())
+		Expect(daily).To(BeEmpty())
+		Expect(weekly).To(BeEmpty())
+	})
+
+	It("handles never interval", func() {
+		vs.On("GetValueByUniqueIdentifiers", mock.Anything, mock.Anything).Return(newGetValueResponseStringValue("never"), nil)
+
+		instant, daily, weekly := s.execute(context.TODO(), newUsers("foo"))
+		Expect(instant).To(BeEmpty())
+		Expect(daily).To(BeEmpty())
+		Expect(weekly).To(BeEmpty())
+	})
+
+	It("handles instant interval", func() {
+		vs.On("GetValueByUniqueIdentifiers", mock.Anything, mock.Anything).Return(newGetValueResponseStringValue("instant"), nil)
+
+		instant, daily, weekly := s.execute(context.TODO(), newUsers("foo"))
+		Expect(instant).To(Equal(newUsers("foo")))
+		Expect(daily).To(BeEmpty())
+		Expect(weekly).To(BeEmpty())
+	})
+
+	It("handles daily interval", func() {
+		vs.On("GetValueByUniqueIdentifiers", mock.Anything, mock.Anything).Return(newGetValueResponseStringValue("daily"), nil)
+
+		instant, daily, weekly := s.execute(context.TODO(), newUsers("foo"))
+		Expect(instant).To(BeEmpty())
+		Expect(daily).To(Equal(newUsers("foo")))
+		Expect(weekly).To(BeEmpty())
+	})
+
+	It("handles weekly interval", func() {
+		vs.On("GetValueByUniqueIdentifiers", mock.Anything, mock.Anything).Return(newGetValueResponseStringValue("weekly"), nil)
+
+		instant, daily, weekly := s.execute(context.TODO(), newUsers("foo"))
+		Expect(instant).To(BeEmpty())
+		Expect(daily).To(BeEmpty())
+		Expect(weekly).To(Equal(newUsers("foo")))
+	})
+
+	It("handles multiple users and intervals", func() {
+		vs.On("GetValueByUniqueIdentifiers", mock.Anything, mock.Anything).Return(func(ctx context.Context, req *settings.GetValueByUniqueIdentifiersRequest, opts ...client.CallOption) *settings.GetValueResponse {
+			if strings.Contains(req.AccountUuid, "never") {
+				return newGetValueResponseStringValue("never")
+			} else if strings.Contains(req.AccountUuid, "instant") {
+				return newGetValueResponseStringValue("instant")
+			} else if strings.Contains(req.AccountUuid, "daily") {
+				return newGetValueResponseStringValue("daily")
+			} else if strings.Contains(req.AccountUuid, "weekly") {
+				return newGetValueResponseStringValue("weekly")
+			}
+			return nil
+		}, nil)
+
+		instant, daily, weekly := s.execute(context.TODO(), newUsers("never1", "instant1", "daily1", "weekly1", "never2", "instant2", "daily2", "weekly2"))
+		Expect(instant).To(Equal(newUsers("instant1", "instant2")))
+		Expect(daily).To(Equal(newUsers("daily1", "daily2")))
+		Expect(weekly).To(Equal(newUsers("weekly1", "weekly2")))
+	})
+})
 
 func newGetValueResponseStringValue(strVal string) *settings.GetValueResponse {
 	return &settings.GetValueResponse{Value: &settingsmsg.ValueWithIdentifier{

services/userlog/pkg/service/filter_test.go

@@ -2,97 +2,177 @@ package service
 
 import (
 	"context"
-	"testing"
 
 	user "github.com/cs3org/go-cs3apis/cs3/identity/user/v1beta1"
 	"github.com/cs3org/reva/v2/pkg/events"
 	"github.com/opencloud-eu/opencloud/pkg/log"
 	settingsmsg "github.com/opencloud-eu/opencloud/protogen/gen/opencloud/messages/settings/v0"
 	settings "github.com/opencloud-eu/opencloud/protogen/gen/opencloud/services/settings/v0"
+	settingsmocks "github.com/opencloud-eu/opencloud/protogen/gen/opencloud/services/settings/v0/mocks"
 	"github.com/pkg/errors"
-	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
-	"go-micro.dev/v4/client"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
 )
 
-var testLogger = log.NewLogger()
+var _ = Describe("NotificationFilter", func() {
+	var (
+		testLogger = log.NewLogger()
+		vs         *settingsmocks.ValueService
+		ulf        userlogFilter
+	)
 
-func TestUserlogFilter_execute(t *testing.T) {
+	BeforeEach(func() {
-	type args struct {
+		vs = &settingsmocks.ValueService{}
-		ctx       context.Context
+		ulf = userlogFilter{
-		event     events.Event
+			log:         testLogger,
-		executant *user.UserId
+			valueClient: vs,
-		users     []string
+		}
-	}
+	})
-	tests := []struct {
-		name string
-		vc   settings.ValueService
-		args args
-		want []string
-	}{
-		{"executant", settings.MockValueService{}, args{executant: &user.UserId{OpaqueId: "executant"}, users: []string{"foo", "executant"}}, []string{"foo"}},
-		{"no connection to ValueService", settings.MockValueService{
-			GetValueByUniqueIdentifiersFunc: func(ctx context.Context, req *settings.GetValueByUniqueIdentifiersRequest, opts ...client.CallOption) (*settings.GetValueResponse, error) {
-				return nil, errors.New("no connection to ValueService")
-			},
-		}, args{users: []string{"foo"}, event: events.Event{Event: events.ShareCreated{}}, ctx: context.TODO()}, []string(nil)},
-		{"no setting in ValueService response", settings.MockValueService{
-			GetValueByUniqueIdentifiersFunc: func(ctx context.Context, req *settings.GetValueByUniqueIdentifiersRequest, opts ...client.CallOption) (*settings.GetValueResponse, error) {
-				return &settings.GetValueResponse{}, nil
-			},
-		}, args{users: []string{"foo"}, event: events.Event{Event: events.ShareCreated{}}, ctx: context.TODO()}, []string(nil)},
-		{"ValueService nil response", settings.MockValueService{
-			GetValueByUniqueIdentifiersFunc: func(ctx context.Context, req *settings.GetValueByUniqueIdentifiersRequest, opts ...client.CallOption) (*settings.GetValueResponse, error) {
-				return nil, nil
-			},
-		}, args{users: []string{"foo"}, event: events.Event{Event: events.ShareCreated{}}, ctx: context.TODO()}, []string(nil)},
-		{"event that cannot be disabled", setupMockValueService(true), args{users: []string{"foo"}, event: events.Event{Event: events.BytesReceived{}}, ctx: context.TODO()}, []string{"foo"}},
-		{"ShareCreated enabled", setupMockValueService(true), args{users: []string{"foo"}, event: events.Event{Event: events.ShareCreated{}}, ctx: context.TODO()}, []string{"foo"}},
-		{"ShareRemoved enabled", setupMockValueService(true), args{users: []string{"foo"}, event: events.Event{Event: events.ShareRemoved{}}, ctx: context.TODO()}, []string{"foo"}},
-		{"ShareExpired enabled", setupMockValueService(true), args{users: []string{"foo"}, event: events.Event{Event: events.ShareExpired{}}, ctx: context.TODO()}, []string{"foo"}},
-		{"SpaceShared enabled", setupMockValueService(true), args{users: []string{"foo"}, event: events.Event{Event: events.SpaceShared{}}, ctx: context.TODO()}, []string{"foo"}},
-		{"SpaceUnshared enabled", setupMockValueService(true), args{users: []string{"foo"}, event: events.Event{Event: events.SpaceUnshared{}}, ctx: context.TODO()}, []string{"foo"}},
-		{"SpaceMembershipExpired enabled", setupMockValueService(true), args{users: []string{"foo"}, event: events.Event{Event: events.SpaceMembershipExpired{}}, ctx: context.TODO()}, []string{"foo"}},
-		{"SpaceDisabled enabled", setupMockValueService(true), args{users: []string{"foo"}, event: events.Event{Event: events.SpaceDisabled{}}, ctx: context.TODO()}, []string{"foo"}},
-		{"SpaceDeleted enabled", setupMockValueService(true), args{users: []string{"foo"}, event: events.Event{Event: events.SpaceDeleted{}}, ctx: context.TODO()}, []string{"foo"}},
-		{"ShareCreated disabled", setupMockValueService(false), args{users: []string{"foo"}, event: events.Event{Event: events.ShareCreated{}}, ctx: context.TODO()}, []string(nil)},
-		{"ShareRemoved disabled", setupMockValueService(false), args{users: []string{"foo"}, event: events.Event{Event: events.ShareRemoved{}}, ctx: context.TODO()}, []string(nil)},
-		{"ShareExpired disabled", setupMockValueService(false), args{users: []string{"foo"}, event: events.Event{Event: events.ShareExpired{}}, ctx: context.TODO()}, []string(nil)},
-		{"SpaceShared disabled", setupMockValueService(false), args{users: []string{"foo"}, event: events.Event{Event: events.SpaceShared{}}, ctx: context.TODO()}, []string(nil)},
-		{"SpaceUnshared disabled", setupMockValueService(false), args{users: []string{"foo"}, event: events.Event{Event: events.SpaceUnshared{}}, ctx: context.TODO()}, []string(nil)},
-		{"SpaceMembershipExpired disabled", setupMockValueService(false), args{users: []string{"foo"}, event: events.Event{Event: events.SpaceMembershipExpired{}}, ctx: context.TODO()}, []string(nil)},
-		{"SpaceDisabled disabled", setupMockValueService(false), args{users: []string{"foo"}, event: events.Event{Event: events.SpaceDisabled{}}, ctx: context.TODO()}, []string(nil)},
-		{"SpaceDeleted disabled", setupMockValueService(false), args{users: []string{"foo"}, event: events.Event{Event: events.SpaceDeleted{}}, ctx: context.TODO()}, []string(nil)},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			ulf := userlogFilter{
-				log:         testLogger,
-				valueClient: tt.vc,
-			}
-			assert.Equal(t, tt.want, ulf.execute(tt.args.ctx, tt.args.event, tt.args.executant, tt.args.users))
-		})
-	}
-}
 
-func setupMockValueService(inApp bool) settings.ValueService {
+	setupMockValueService := func(inApp bool) *settingsmocks.ValueService {
-	return settings.MockValueService{
+		vs := settingsmocks.ValueService{}
-		GetValueByUniqueIdentifiersFunc: func(ctx context.Context, req *settings.GetValueByUniqueIdentifiersRequest, opts ...client.CallOption) (*settings.GetValueResponse, error) {
+		vs.On("GetValueByUniqueIdentifiers", mock.Anything, mock.Anything).Return(&settings.GetValueResponse{
-			return &settings.GetValueResponse{
+			Value: &settingsmsg.ValueWithIdentifier{
-				Value: &settingsmsg.ValueWithIdentifier{
+				Value: &settingsmsg.Value{
-					Value: &settingsmsg.Value{
+					Value: &settingsmsg.Value_CollectionValue{
-						Value: &settingsmsg.Value_CollectionValue{
+						CollectionValue: &settingsmsg.CollectionValue{
-							CollectionValue: &settingsmsg.CollectionValue{
+							Values: []*settingsmsg.CollectionOption{
-								Values: []*settingsmsg.CollectionOption{
+								{
-									{
+									Key:    "in-app",
-										Key:    "in-app",
+									Option: &settingsmsg.CollectionOption_BoolValue{BoolValue: inApp},
-										Option: &settingsmsg.CollectionOption_BoolValue{BoolValue: inApp},
-									},
 								},
 							},
 						},
 					},
 				},
-			}, nil
+			},
-		},
+		}, nil)
+		return &vs
 	}
-}
+
+	Describe("execute", func() {
+		It("handles executants", func() {
+			vs.On("GetValueByUniqueIdentifiers", mock.Anything, mock.Anything).Return(nil, nil)
+
+			Expect(ulf.execute(context.TODO(), events.Event{}, &user.UserId{OpaqueId: "executant"}, []string{"foo"})).To(ConsistOf("foo"))
+		})
+		It("handles connection errors", func() {
+			vs.On("GetValueByUniqueIdentifiers", mock.Anything, mock.Anything).Return(nil, errors.New("no connection to ValueService"))
+
+			Expect(ulf.execute(context.TODO(), events.Event{Event: events.ShareCreated{}}, nil, []string{"foo"})).To(BeEmpty())
+		})
+		It("handles no setting", func() {
+			vs.On("GetValueByUniqueIdentifiers", mock.Anything, mock.Anything).Return(&settings.GetValueResponse{}, nil)
+
+			Expect(ulf.execute(context.TODO(), events.Event{Event: events.ShareCreated{}}, nil, []string{"foo"})).To(BeEmpty())
+		})
+		It("handles nil response", func() {
+			vs.On("GetValueByUniqueIdentifiers", mock.Anything, mock.Anything).Return(nil, nil)
+
+			Expect(ulf.execute(context.TODO(), events.Event{Event: events.ShareCreated{}}, nil, []string{"foo"})).To(BeEmpty())
+		})
+		It("handles events that can not be disabled", func() {
+			ulf.valueClient = setupMockValueService(true)
+
+			Expect(ulf.execute(context.TODO(), events.Event{Event: events.BytesReceived{}}, nil, []string{"foo"})).To(ConsistOf("foo"))
+		})
+
+		It("handles ShareCreated events", func() {
+			ulf.valueClient = setupMockValueService(true)
+
+			Expect(ulf.execute(context.TODO(), events.Event{Event: events.ShareCreated{}}, nil, []string{"foo"})).To(ConsistOf("foo"))
+		})
+
+		It("handles ShareRemoved events", func() {
+			ulf.valueClient = setupMockValueService(true)
+
+			Expect(ulf.execute(context.TODO(), events.Event{Event: events.ShareRemoved{}}, nil, []string{"foo"})).To(ConsistOf("foo"))
+		})
+
+		It("handles ShareExpired events", func() {
+			ulf.valueClient = setupMockValueService(true)
+
+			Expect(ulf.execute(context.TODO(), events.Event{Event: events.ShareExpired{}}, nil, []string{"foo"})).To(ConsistOf("foo"))
+		})
+
+		It("handles SpaceShared enabled", func() {
+			ulf.valueClient = setupMockValueService(true)
+
+			Expect(ulf.execute(context.TODO(), events.Event{Event: events.SpaceShared{}}, nil, []string{"foo"})).To(ConsistOf("foo"))
+		})
+
+		It("handles SpaceUnshared enabled", func() {
+			ulf.valueClient = setupMockValueService(true)
+
+			Expect(ulf.execute(context.TODO(), events.Event{Event: events.SpaceUnshared{}}, nil, []string{"foo"})).To(ConsistOf("foo"))
+		})
+
+		It("handles SpaceMembershipExpired enabled", func() {
+			ulf.valueClient = setupMockValueService(true)
+
+			Expect(ulf.execute(context.TODO(), events.Event{Event: events.SpaceMembershipExpired{}}, nil, []string{"foo"})).To(ConsistOf("foo"))
+		})
+
+		It("handles SpaceDisabled enabled", func() {
+			ulf.valueClient = setupMockValueService(true)
+
+			Expect(ulf.execute(context.TODO(), events.Event{Event: events.SpaceDisabled{}}, nil, []string{"foo"})).To(ConsistOf("foo"))
+		})
+
+		It("handles SpaceDeleted enabled", func() {
+			ulf.valueClient = setupMockValueService(true)
+
+			Expect(ulf.execute(context.TODO(), events.Event{Event: events.SpaceDeleted{}}, nil, []string{"foo"})).To(ConsistOf("foo"))
+		})
+
+		It("handles ShareCreated disabled", func() {
+			ulf.valueClient = setupMockValueService(false)
+
+			Expect(ulf.execute(context.TODO(), events.Event{Event: events.ShareCreated{}}, nil, []string{"foo"})).To(BeEmpty())
+		})
+
+		It("handles ShareRemoved disabled", func() {
+			ulf.valueClient = setupMockValueService(false)
+
+			Expect(ulf.execute(context.TODO(), events.Event{Event: events.ShareRemoved{}}, nil, []string{"foo"})).To(BeEmpty())
+		})
+
+		It("handles ShareExpired disabled", func() {
+			ulf.valueClient = setupMockValueService(false)
+
+			Expect(ulf.execute(context.TODO(), events.Event{Event: events.ShareExpired{}}, nil, []string{"foo"})).To(BeEmpty())
+		})
+
+		It("handles SpaceShared disabled", func() {
+			ulf.valueClient = setupMockValueService(false)
+
+			Expect(ulf.execute(context.TODO(), events.Event{Event: events.SpaceShared{}}, nil, []string{"foo"})).To(BeEmpty())
+		})
+
+		It("handles SpaceUnshared disabled", func() {
+			ulf.valueClient = setupMockValueService(false)
+
+			Expect(ulf.execute(context.TODO(), events.Event{Event: events.SpaceUnshared{}}, nil, []string{"foo"})).To(BeEmpty())
+		})
+
+		It("handles SpaceMembershipExpired disabled", func() {
+			ulf.valueClient = setupMockValueService(false)
+
+			Expect(ulf.execute(context.TODO(), events.Event{Event: events.SpaceMembershipExpired{}}, nil, []string{"foo"})).To(BeEmpty())
+		})
+
+		It("handles SpaceDisabled disabled", func() {
+			ulf.valueClient = setupMockValueService(false)
+
+			Expect(ulf.execute(context.TODO(), events.Event{Event: events.SpaceDisabled{}}, nil, []string{"foo"})).To(BeEmpty())
+		})
+
+		It("handles SpaceDeleted disabled", func() {
+			ulf.valueClient = setupMockValueService(false)
+
+			Expect(ulf.execute(context.TODO(), events.Event{Event: events.SpaceDeleted{}}, nil, []string{"foo"})).To(BeEmpty())
+		})
+	})
+})

services/userlog/pkg/service/service_test.go

@@ -22,7 +22,6 @@ import (
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 	"github.com/stretchr/testify/mock"
-	"go-micro.dev/v4/client"
 	microevents "go-micro.dev/v4/events"
 	microstore "go-micro.dev/v4/store"
 	"go.opentelemetry.io/otel/trace"
@@ -33,6 +32,7 @@ import (
 	ehsvc "github.com/opencloud-eu/opencloud/protogen/gen/opencloud/services/eventhistory/v0"
 	"github.com/opencloud-eu/opencloud/protogen/gen/opencloud/services/eventhistory/v0/mocks"
 	settingssvc "github.com/opencloud-eu/opencloud/protogen/gen/opencloud/services/settings/v0"
+	settingsmocks "github.com/opencloud-eu/opencloud/protogen/gen/opencloud/services/settings/v0/mocks"
 	"github.com/opencloud-eu/opencloud/services/userlog/pkg/config"
 	"github.com/opencloud-eu/opencloud/services/userlog/pkg/service"
 )
@@ -51,7 +51,7 @@ var _ = Describe("UserlogService", func() {
 		gatewaySelector pool.Selectable[gateway.GatewayAPIClient]
 
 		ehc mocks.EventHistoryService
-		vc  settingssvc.MockValueService
+		vc  settingsmocks.ValueService
 	)
 
 	BeforeEach(func() {
@@ -78,24 +78,22 @@ var _ = Describe("UserlogService", func() {
 		}, Status: &rpc.Status{Code: rpc.Code_CODE_OK}}, nil)
 		gatewayClient.On("GetUser", mock.Anything, mock.Anything).Return(&user.GetUserResponse{User: &user.User{Id: &user.UserId{OpaqueId: "userid"}}, Status: &rpc.Status{Code: rpc.Code_CODE_OK}}, nil)
 		gatewayClient.On("Authenticate", mock.Anything, mock.Anything).Return(&gateway.AuthenticateResponse{Status: &rpc.Status{Code: rpc.Code_CODE_OK}}, nil)
-		vc.GetValueByUniqueIdentifiersFunc = func(ctx context.Context, req *settingssvc.GetValueByUniqueIdentifiersRequest, opts ...client.CallOption) (*settingssvc.GetValueResponse, error) {
+		vc.On("GetValueByUniqueIdentifiers", mock.Anything, mock.Anything).Return(&settingssvc.GetValueResponse{
-			return &settingssvc.GetValueResponse{
+			Value: &settingsmsg.ValueWithIdentifier{
-				Value: &settingsmsg.ValueWithIdentifier{
+				Value: &settingsmsg.Value{
-					Value: &settingsmsg.Value{
+					Value: &settingsmsg.Value_CollectionValue{
-						Value: &settingsmsg.Value_CollectionValue{
+						CollectionValue: &settingsmsg.CollectionValue{
-							CollectionValue: &settingsmsg.CollectionValue{
+							Values: []*settingsmsg.CollectionOption{
-								Values: []*settingsmsg.CollectionOption{
+								{
-									{
+									Key:    "in-app",
-										Key:    "in-app",
+									Option: &settingsmsg.CollectionOption_BoolValue{BoolValue: true},
-										Option: &settingsmsg.CollectionOption_BoolValue{BoolValue: true},
-									},
 								},
 							},
 						},
 					},
 				},
-			}, nil
+			},
-		}
+		}, nil)
 
 		ul, err = service.NewUserlogService(
 			service.Config(cfg),