mirror/opencloud
1
0
Fork 0
mirror of https://github.com/opencloud-eu/opencloud.git synced 2025-12-30 17:00:57 -06:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
Fix tests
This commit is contained in:
Michael Barz
2025-01-16 09:35:13 +01:00
committed by GitHub
parent d07cc2fdcb 6cad539024
commit 6833ccc1f3
5 changed files with 384 additions and 350 deletions
Download Patch File Download Diff File Expand all files Collapse all files

133
services/notifications/pkg/service/filter_test.go
View File

@@ -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())
})
})
})

58
services/notifications/pkg/service/service_test.go
View File

@@ -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: "<script>alert('secrets of the board');</script>",
Space: &provider.StorageSpace{Name: "<script>alert('secret space');</script>"}},
}, 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",

281
services/notifications/pkg/service/splitter_test.go
View File

@@ -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{

234
services/userlog/pkg/service/filter_test.go
View File

@@ -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())
})
})
})

28
services/userlog/pkg/service/service_test.go
View File

@@ -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),