diff --git a/services/notifications/pkg/service/filter_test.go b/services/notifications/pkg/service/filter_test.go
index 60b8d9d41..4fdd4135a 100644
--- a/services/notifications/pkg/service/filter_test.go
+++ b/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"
- "go-micro.dev/v4/client"
+ "github.com/stretchr/testify/mock"
+
+ . "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) {
- type args struct {
- ctx context.Context
- users []*user.User
- settingId string
- }
- tests := []struct {
- name string
- vc settings.ValueService
- args args
- want []*user.User
- }{
- {"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},
- },
+ setupMockValueService := func(mail bool) *settingsmocks.ValueService {
+ m := &settingsmocks.ValueService{}
+ m.On("GetValueByUniqueIdentifiers", mock.Anything, mock.Anything).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())
+ })
+ })
+})
diff --git a/services/notifications/pkg/service/service_test.go b/services/notifications/pkg/service/service_test.go
index 1ffa20f93..442382507 100644
--- a/services/notifications/pkg/service/service_test.go
+++ b/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.GetValueByUniqueIdentifiersFunc = func(ctx context.Context, req *settingssvc.GetValueByUniqueIdentifiersRequest, opts ...client.CallOption) (*settingssvc.GetValueResponse, error) {
- return &settingssvc.GetValueResponse{
- Value: &settingsmsg.ValueWithIdentifier{
- Value: &settingsmsg.Value{
- Value: &settingsmsg.Value_CollectionValue{
- CollectionValue: &settingsmsg.CollectionValue{
- Values: []*settingsmsg.CollectionOption{
- {
- Key: "mail",
- Option: &settingsmsg.CollectionOption_BoolValue{BoolValue: true},
- },
+ vs = &settingsmocks.ValueService{}
+ vs.On("GetValueByUniqueIdentifiers", mock.Anything, mock.Anything).Return(&settingssvc.GetValueResponse{
+ Value: &settingsmsg.ValueWithIdentifier{
+ Value: &settingsmsg.Value{
+ Value: &settingsmsg.Value_CollectionValue{
+ CollectionValue: &settingsmsg.CollectionValue{
+ Values: []*settingsmsg.CollectionOption{
+ {
+ Key: "mail",
+ 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: "",
Space: &provider.StorageSpace{Name: ""}},
}, nil)
- vs = &settingssvc.MockValueService{}
- vs.GetValueByUniqueIdentifiersFunc = func(ctx context.Context, req *settingssvc.GetValueByUniqueIdentifiersRequest, opts ...client.CallOption) (*settingssvc.GetValueResponse, error) {
- return &settingssvc.GetValueResponse{
- Value: &settingsmsg.ValueWithIdentifier{
- Value: &settingsmsg.Value{
- Value: &settingsmsg.Value_CollectionValue{
- CollectionValue: &settingsmsg.CollectionValue{
- Values: []*settingsmsg.CollectionOption{
- {
- Key: "mail",
- Option: &settingsmsg.CollectionOption_BoolValue{BoolValue: true},
- },
+ vs = &settingsmocks.ValueService{}
+ vs.On("GetValueByUniqueIdentifiers", mock.Anything, mock.Anything).Return(&settingssvc.GetValueResponse{
+ Value: &settingsmsg.ValueWithIdentifier{
+ Value: &settingsmsg.Value{
+ Value: &settingsmsg.Value_CollectionValue{
+ CollectionValue: &settingsmsg.CollectionValue{
+ Values: []*settingsmsg.CollectionOption{
+ {
+ Key: "mail",
+ Option: &settingsmsg.CollectionOption_BoolValue{BoolValue: true},
},
},
},
},
},
- }, nil
- }
+ },
+ }, nil)
})
DescribeTable("Sending userEventIds",
diff --git a/services/notifications/pkg/service/splitter_test.go b/services/notifications/pkg/service/splitter_test.go
index 65c95b362..d85936ed4 100644
--- a/services/notifications/pkg/service/splitter_test.go
+++ b/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"
- "github.com/pkg/errors"
- "github.com/stretchr/testify/assert"
- "go-micro.dev/v4/client"
+ settingsmocks "github.com/opencloud-eu/opencloud/protogen/gen/opencloud/services/settings/v0/mocks"
+
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
)
-func Test_intervalSplitter_execute(t *testing.T) {
- type fields struct {
- log log.Logger
- 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)
- })
- }
-}
+var _ = Describe("NotificationFilter", func() {
+ var (
+ testLogger = log.NewLogger()
-func newStringValueMockValueService(strVal string) settings.ValueService {
- return settings.MockValueService{
- GetValueByUniqueIdentifiersFunc: func(ctx context.Context, req *settings.GetValueByUniqueIdentifiersRequest, opts ...client.CallOption) (*settings.GetValueResponse, error) {
- return newGetValueResponseStringValue(strVal), nil
- },
- }
-}
+ vs *settingsmocks.ValueService
+ s intervalSplitter
+ )
+
+ 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{
diff --git a/services/userlog/pkg/service/filter_test.go b/services/userlog/pkg/service/filter_test.go
index a768ee569..b96e12c85 100644
--- a/services/userlog/pkg/service/filter_test.go
+++ b/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"
- "go-micro.dev/v4/client"
+ "github.com/stretchr/testify/mock"
+
+ . "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) {
- type args struct {
- ctx context.Context
- event events.Event
- executant *user.UserId
- 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))
- })
- }
-}
+ BeforeEach(func() {
+ vs = &settingsmocks.ValueService{}
+ ulf = userlogFilter{
+ log: testLogger,
+ valueClient: vs,
+ }
+ })
-func setupMockValueService(inApp 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: "in-app",
- Option: &settingsmsg.CollectionOption_BoolValue{BoolValue: inApp},
- },
+ setupMockValueService := func(inApp bool) *settingsmocks.ValueService {
+ vs := settingsmocks.ValueService{}
+ vs.On("GetValueByUniqueIdentifiers", mock.Anything, mock.Anything).Return(&settings.GetValueResponse{
+ Value: &settingsmsg.ValueWithIdentifier{
+ Value: &settingsmsg.Value{
+ Value: &settingsmsg.Value_CollectionValue{
+ CollectionValue: &settingsmsg.CollectionValue{
+ Values: []*settingsmsg.CollectionOption{
+ {
+ Key: "in-app",
+ 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())
+ })
+ })
+})
diff --git a/services/userlog/pkg/service/service_test.go b/services/userlog/pkg/service/service_test.go
index 967c8fc85..9152dfc8c 100644
--- a/services/userlog/pkg/service/service_test.go
+++ b/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) {
- return &settingssvc.GetValueResponse{
- Value: &settingsmsg.ValueWithIdentifier{
- Value: &settingsmsg.Value{
- Value: &settingsmsg.Value_CollectionValue{
- CollectionValue: &settingsmsg.CollectionValue{
- Values: []*settingsmsg.CollectionOption{
- {
- Key: "in-app",
- Option: &settingsmsg.CollectionOption_BoolValue{BoolValue: true},
- },
+ vc.On("GetValueByUniqueIdentifiers", mock.Anything, mock.Anything).Return(&settingssvc.GetValueResponse{
+ Value: &settingsmsg.ValueWithIdentifier{
+ Value: &settingsmsg.Value{
+ Value: &settingsmsg.Value_CollectionValue{
+ CollectionValue: &settingsmsg.CollectionValue{
+ Values: []*settingsmsg.CollectionOption{
+ {
+ Key: "in-app",
+ Option: &settingsmsg.CollectionOption_BoolValue{BoolValue: true},
},
},
},
},
},
- }, nil
- }
+ },
+ }, nil)
ul, err = service.NewUserlogService(
service.Config(cfg),