mirror of
https://github.com/zitadel/zitadel.git
synced 2024-12-16 04:48:04 +00:00
cb7b50b513
* feat: enable only specific themes in label policy * feat: enable only specific themes in label policy * feat: enable only specific themes in label policy * feat: enable only specific themes in label policy * add management in console * pass enabledTheme * render login ui based on enabled theme * add in branding / settings service and name consistently * update console to latest proto state * fix console linting * fix linting * cleanup * add translations --------- Co-authored-by: Livio Spring <livio.a@gmail.com> Co-authored-by: Tim Möhlmann <tim+github@zitadel.com>
2124 lines
45 KiB
Go
2124 lines
45 KiB
Go
package command
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"testing"
|
|
|
|
"github.com/golang/mock/gomock"
|
|
"github.com/stretchr/testify/assert"
|
|
|
|
"github.com/zitadel/zitadel/internal/domain"
|
|
caos_errs "github.com/zitadel/zitadel/internal/errors"
|
|
"github.com/zitadel/zitadel/internal/eventstore"
|
|
"github.com/zitadel/zitadel/internal/eventstore/v1/models"
|
|
"github.com/zitadel/zitadel/internal/repository/org"
|
|
"github.com/zitadel/zitadel/internal/repository/policy"
|
|
"github.com/zitadel/zitadel/internal/static"
|
|
"github.com/zitadel/zitadel/internal/static/mock"
|
|
)
|
|
|
|
func TestCommandSide_AddLabelPolicy(t *testing.T) {
|
|
type fields struct {
|
|
eventstore *eventstore.Eventstore
|
|
}
|
|
type args struct {
|
|
ctx context.Context
|
|
orgID string
|
|
policy *domain.LabelPolicy
|
|
}
|
|
type res struct {
|
|
want *domain.LabelPolicy
|
|
err func(error) bool
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
fields fields
|
|
args args
|
|
res res
|
|
}{
|
|
{
|
|
name: "org id missing, invalid argument error",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
policy: &domain.LabelPolicy{
|
|
PrimaryColor: "",
|
|
BackgroundColor: "#ffffff",
|
|
},
|
|
},
|
|
res: res{
|
|
err: caos_errs.IsErrorInvalidArgument,
|
|
},
|
|
},
|
|
{
|
|
name: "labelpolicy already existing, already exists error",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
expectFilter(
|
|
eventFromEventPusher(
|
|
org.NewLabelPolicyAddedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate,
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
true,
|
|
true,
|
|
true,
|
|
domain.LabelPolicyThemeAuto,
|
|
),
|
|
),
|
|
),
|
|
),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "org1",
|
|
policy: &domain.LabelPolicy{
|
|
PrimaryColor: "#ffffff",
|
|
BackgroundColor: "#ffffff",
|
|
WarnColor: "#ffffff",
|
|
FontColor: "#ffffff",
|
|
PrimaryColorDark: "#ffffff",
|
|
BackgroundColorDark: "#ffffff",
|
|
WarnColorDark: "#ffffff",
|
|
FontColorDark: "#ffffff",
|
|
HideLoginNameSuffix: true,
|
|
ErrorMsgPopup: true,
|
|
DisableWatermark: true,
|
|
},
|
|
},
|
|
res: res{
|
|
err: caos_errs.IsErrorAlreadyExists,
|
|
},
|
|
},
|
|
{
|
|
name: "add policy,ok",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
expectFilter(),
|
|
expectPush(
|
|
org.NewLabelPolicyAddedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate,
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
true,
|
|
true,
|
|
true,
|
|
domain.LabelPolicyThemeDark,
|
|
),
|
|
),
|
|
),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "org1",
|
|
policy: &domain.LabelPolicy{
|
|
PrimaryColor: "#ffffff",
|
|
BackgroundColor: "#ffffff",
|
|
WarnColor: "#ffffff",
|
|
FontColor: "#ffffff",
|
|
PrimaryColorDark: "#ffffff",
|
|
BackgroundColorDark: "#ffffff",
|
|
WarnColorDark: "#ffffff",
|
|
FontColorDark: "#ffffff",
|
|
HideLoginNameSuffix: true,
|
|
ErrorMsgPopup: true,
|
|
DisableWatermark: true,
|
|
ThemeMode: domain.LabelPolicyThemeDark,
|
|
},
|
|
},
|
|
res: res{
|
|
want: &domain.LabelPolicy{
|
|
ObjectRoot: models.ObjectRoot{
|
|
AggregateID: "org1",
|
|
ResourceOwner: "org1",
|
|
},
|
|
PrimaryColor: "#ffffff",
|
|
BackgroundColor: "#ffffff",
|
|
WarnColor: "#ffffff",
|
|
FontColor: "#ffffff",
|
|
PrimaryColorDark: "#ffffff",
|
|
BackgroundColorDark: "#ffffff",
|
|
WarnColorDark: "#ffffff",
|
|
FontColorDark: "#ffffff",
|
|
HideLoginNameSuffix: true,
|
|
ErrorMsgPopup: true,
|
|
DisableWatermark: true,
|
|
ThemeMode: domain.LabelPolicyThemeDark,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
r := &Commands{
|
|
eventstore: tt.fields.eventstore,
|
|
}
|
|
got, err := r.AddLabelPolicy(tt.args.ctx, tt.args.orgID, tt.args.policy)
|
|
if tt.res.err == nil {
|
|
assert.NoError(t, err)
|
|
}
|
|
if tt.res.err != nil && !tt.res.err(err) {
|
|
t.Errorf("got wrong err: %v ", err)
|
|
}
|
|
if tt.res.err == nil {
|
|
assert.Equal(t, tt.res.want, got)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCommandSide_ChangeLabelPolicy(t *testing.T) {
|
|
type fields struct {
|
|
eventstore *eventstore.Eventstore
|
|
}
|
|
type args struct {
|
|
ctx context.Context
|
|
orgID string
|
|
policy *domain.LabelPolicy
|
|
}
|
|
type res struct {
|
|
want *domain.LabelPolicy
|
|
err func(error) bool
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
fields fields
|
|
args args
|
|
res res
|
|
}{
|
|
{
|
|
name: "org id missing, invalid argument error",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
policy: &domain.LabelPolicy{
|
|
PrimaryColor: "#ffffff",
|
|
BackgroundColor: "#ffffff",
|
|
},
|
|
},
|
|
res: res{
|
|
err: caos_errs.IsErrorInvalidArgument,
|
|
},
|
|
},
|
|
{
|
|
name: "labelpolicy not existing, not found error",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
expectFilter(),
|
|
),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "org1",
|
|
policy: &domain.LabelPolicy{
|
|
PrimaryColor: "#ffffff",
|
|
BackgroundColor: "#ffffff",
|
|
WarnColor: "#ffffff",
|
|
},
|
|
},
|
|
res: res{
|
|
err: caos_errs.IsNotFound,
|
|
},
|
|
},
|
|
{
|
|
name: "no changes, precondition error",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
expectFilter(
|
|
eventFromEventPusher(
|
|
org.NewLabelPolicyAddedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate,
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
true,
|
|
true,
|
|
true,
|
|
domain.LabelPolicyThemeAuto,
|
|
),
|
|
),
|
|
),
|
|
),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "org1",
|
|
policy: &domain.LabelPolicy{
|
|
PrimaryColor: "#ffffff",
|
|
BackgroundColor: "#ffffff",
|
|
WarnColor: "#ffffff",
|
|
FontColor: "#ffffff",
|
|
PrimaryColorDark: "#ffffff",
|
|
BackgroundColorDark: "#ffffff",
|
|
WarnColorDark: "#ffffff",
|
|
FontColorDark: "#ffffff",
|
|
HideLoginNameSuffix: true,
|
|
ErrorMsgPopup: true,
|
|
DisableWatermark: true,
|
|
ThemeMode: domain.LabelPolicyThemeAuto,
|
|
},
|
|
},
|
|
res: res{
|
|
err: caos_errs.IsPreconditionFailed,
|
|
},
|
|
},
|
|
{
|
|
name: "change, ok",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
expectFilter(
|
|
eventFromEventPusher(
|
|
org.NewLabelPolicyAddedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate,
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
true,
|
|
true,
|
|
true,
|
|
domain.LabelPolicyThemeAuto,
|
|
),
|
|
),
|
|
),
|
|
expectPush(
|
|
newLabelPolicyChangedEvent(
|
|
context.Background(),
|
|
"org1",
|
|
"#000000",
|
|
"#000000",
|
|
"#000000",
|
|
"#000000",
|
|
"#000000",
|
|
"#000000",
|
|
"#000000",
|
|
"#000000",
|
|
false,
|
|
false,
|
|
false,
|
|
domain.LabelPolicyThemeDark),
|
|
),
|
|
),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "org1",
|
|
policy: &domain.LabelPolicy{
|
|
PrimaryColor: "#000000",
|
|
BackgroundColor: "#000000",
|
|
WarnColor: "#000000",
|
|
FontColor: "#000000",
|
|
PrimaryColorDark: "#000000",
|
|
BackgroundColorDark: "#000000",
|
|
WarnColorDark: "#000000",
|
|
FontColorDark: "#000000",
|
|
HideLoginNameSuffix: false,
|
|
ErrorMsgPopup: false,
|
|
DisableWatermark: false,
|
|
ThemeMode: domain.LabelPolicyThemeDark,
|
|
},
|
|
},
|
|
res: res{
|
|
want: &domain.LabelPolicy{
|
|
ObjectRoot: models.ObjectRoot{
|
|
AggregateID: "org1",
|
|
ResourceOwner: "org1",
|
|
},
|
|
PrimaryColor: "#000000",
|
|
BackgroundColor: "#000000",
|
|
WarnColor: "#000000",
|
|
FontColor: "#000000",
|
|
PrimaryColorDark: "#000000",
|
|
BackgroundColorDark: "#000000",
|
|
WarnColorDark: "#000000",
|
|
FontColorDark: "#000000",
|
|
HideLoginNameSuffix: false,
|
|
ErrorMsgPopup: false,
|
|
DisableWatermark: false,
|
|
ThemeMode: domain.LabelPolicyThemeDark,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
r := &Commands{
|
|
eventstore: tt.fields.eventstore,
|
|
}
|
|
got, err := r.ChangeLabelPolicy(tt.args.ctx, tt.args.orgID, tt.args.policy)
|
|
if tt.res.err == nil {
|
|
assert.NoError(t, err)
|
|
}
|
|
if tt.res.err != nil && !tt.res.err(err) {
|
|
t.Errorf("got wrong err: %v ", err)
|
|
}
|
|
if tt.res.err == nil {
|
|
assert.Equal(t, tt.res.want, got)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCommandSide_ActivateLabelPolicy(t *testing.T) {
|
|
type fields struct {
|
|
eventstore *eventstore.Eventstore
|
|
}
|
|
type args struct {
|
|
ctx context.Context
|
|
orgID string
|
|
}
|
|
type res struct {
|
|
err func(error) bool
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
fields fields
|
|
args args
|
|
res res
|
|
}{
|
|
{
|
|
name: "org id missing, invalid argument error",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
},
|
|
res: res{
|
|
err: caos_errs.IsErrorInvalidArgument,
|
|
},
|
|
},
|
|
{
|
|
name: "label policy not existing, not found error",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
expectFilter(),
|
|
),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "org1",
|
|
},
|
|
res: res{
|
|
err: caos_errs.IsNotFound,
|
|
},
|
|
},
|
|
{
|
|
name: "activate, ok",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
expectFilter(
|
|
eventFromEventPusher(
|
|
org.NewLabelPolicyAddedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate,
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
true,
|
|
true,
|
|
true,
|
|
domain.LabelPolicyThemeAuto,
|
|
),
|
|
),
|
|
),
|
|
expectPush(
|
|
org.NewLabelPolicyActivatedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate),
|
|
),
|
|
),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "org1",
|
|
},
|
|
res: res{},
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
r := &Commands{
|
|
eventstore: tt.fields.eventstore,
|
|
}
|
|
_, err := r.ActivateLabelPolicy(tt.args.ctx, tt.args.orgID)
|
|
if tt.res.err == nil {
|
|
assert.NoError(t, err)
|
|
}
|
|
if tt.res.err != nil && !tt.res.err(err) {
|
|
t.Errorf("got wrong err: %v ", err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCommandSide_RemoveLabelPolicy(t *testing.T) {
|
|
type fields struct {
|
|
eventstore *eventstore.Eventstore
|
|
static static.Storage
|
|
}
|
|
type args struct {
|
|
ctx context.Context
|
|
orgID string
|
|
}
|
|
type res struct {
|
|
err func(error) bool
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
fields fields
|
|
args args
|
|
res res
|
|
}{
|
|
{
|
|
name: "org id missing, invalid argument error",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
},
|
|
res: res{
|
|
err: caos_errs.IsErrorInvalidArgument,
|
|
},
|
|
},
|
|
{
|
|
name: "labelpolicy not existing, not found error",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
expectFilter(),
|
|
),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "org1",
|
|
},
|
|
res: res{
|
|
err: caos_errs.IsNotFound,
|
|
},
|
|
},
|
|
{
|
|
name: "remove, ok",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
expectFilter(
|
|
eventFromEventPusher(
|
|
org.NewLabelPolicyAddedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate,
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
true,
|
|
true,
|
|
true,
|
|
domain.LabelPolicyThemeAuto,
|
|
),
|
|
),
|
|
),
|
|
expectPush(
|
|
org.NewLabelPolicyRemovedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate),
|
|
),
|
|
),
|
|
static: mock.NewMockStorage(gomock.NewController(t)).ExpectRemoveObjectsNoError(),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "org1",
|
|
},
|
|
res: res{},
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
r := &Commands{
|
|
eventstore: tt.fields.eventstore,
|
|
static: tt.fields.static,
|
|
}
|
|
_, err := r.RemoveLabelPolicy(tt.args.ctx, tt.args.orgID)
|
|
if tt.res.err == nil {
|
|
assert.NoError(t, err)
|
|
}
|
|
if tt.res.err != nil && !tt.res.err(err) {
|
|
t.Errorf("got wrong err: %v ", err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCommandSide_AddLogoLabelPolicy(t *testing.T) {
|
|
type fields struct {
|
|
eventstore *eventstore.Eventstore
|
|
storage static.Storage
|
|
}
|
|
type args struct {
|
|
ctx context.Context
|
|
orgID string
|
|
upload *AssetUpload
|
|
}
|
|
type res struct {
|
|
want *domain.ObjectDetails
|
|
err func(error) bool
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
fields fields
|
|
args args
|
|
res res
|
|
}{
|
|
{
|
|
name: "orgID empty, invalid argument error",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "",
|
|
upload: &AssetUpload{
|
|
ResourceOwner: "org1",
|
|
ObjectName: "logo",
|
|
ContentType: "image",
|
|
ObjectType: static.ObjectTypeStyling,
|
|
File: bytes.NewReader([]byte("test")),
|
|
Size: 4,
|
|
},
|
|
},
|
|
res: res{
|
|
err: caos_errs.IsErrorInvalidArgument,
|
|
},
|
|
},
|
|
{
|
|
name: "label policy not existing, not found error",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
expectFilter(),
|
|
),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "org1",
|
|
upload: &AssetUpload{
|
|
ResourceOwner: "org1",
|
|
ObjectName: "logo",
|
|
ContentType: "image",
|
|
ObjectType: static.ObjectTypeStyling,
|
|
File: bytes.NewReader([]byte("test")),
|
|
Size: 4,
|
|
},
|
|
},
|
|
res: res{
|
|
err: caos_errs.IsNotFound,
|
|
},
|
|
},
|
|
{
|
|
name: "upload failed, error",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
expectFilter(
|
|
eventFromEventPusher(
|
|
org.NewLabelPolicyAddedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate,
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
true,
|
|
true,
|
|
true,
|
|
domain.LabelPolicyThemeAuto,
|
|
),
|
|
),
|
|
),
|
|
),
|
|
storage: mock.NewStorage(t).ExpectPutObjectError(),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "org1",
|
|
upload: &AssetUpload{
|
|
ResourceOwner: "org1",
|
|
ObjectName: "logo",
|
|
ContentType: "image",
|
|
ObjectType: static.ObjectTypeStyling,
|
|
File: bytes.NewReader([]byte("test")),
|
|
Size: 4,
|
|
},
|
|
},
|
|
res: res{
|
|
err: caos_errs.IsInternal,
|
|
},
|
|
},
|
|
{
|
|
name: "logo added, ok",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
expectFilter(
|
|
eventFromEventPusher(
|
|
org.NewLabelPolicyAddedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate,
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
true,
|
|
true,
|
|
true,
|
|
domain.LabelPolicyThemeAuto,
|
|
),
|
|
),
|
|
),
|
|
expectPush(
|
|
org.NewLabelPolicyLogoAddedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate,
|
|
"logo",
|
|
),
|
|
),
|
|
),
|
|
storage: mock.NewStorage(t).ExpectPutObject(),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "org1",
|
|
upload: &AssetUpload{
|
|
ResourceOwner: "org1",
|
|
ObjectName: "logo",
|
|
ContentType: "image",
|
|
ObjectType: static.ObjectTypeStyling,
|
|
File: bytes.NewReader([]byte("test")),
|
|
Size: 4,
|
|
},
|
|
},
|
|
res: res{
|
|
want: &domain.ObjectDetails{
|
|
ResourceOwner: "org1",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
r := &Commands{
|
|
eventstore: tt.fields.eventstore,
|
|
static: tt.fields.storage,
|
|
}
|
|
got, err := r.AddLogoLabelPolicy(tt.args.ctx, tt.args.orgID, tt.args.upload)
|
|
if tt.res.err == nil {
|
|
assert.NoError(t, err)
|
|
}
|
|
if tt.res.err != nil && !tt.res.err(err) {
|
|
t.Errorf("got wrong err: %v ", err)
|
|
}
|
|
if tt.res.err == nil {
|
|
assert.Equal(t, tt.res.want, got)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCommandSide_RemoveLogoLabelPolicy(t *testing.T) {
|
|
type fields struct {
|
|
eventstore *eventstore.Eventstore
|
|
storage static.Storage
|
|
}
|
|
type args struct {
|
|
ctx context.Context
|
|
orgID string
|
|
storageKey string
|
|
}
|
|
type res struct {
|
|
want *domain.ObjectDetails
|
|
err func(error) bool
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
fields fields
|
|
args args
|
|
res res
|
|
}{
|
|
{
|
|
name: "orgID empty, invalid argument error",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
storageKey: "key",
|
|
},
|
|
res: res{
|
|
err: caos_errs.IsErrorInvalidArgument,
|
|
},
|
|
},
|
|
{
|
|
name: "label policy not existing, not found error",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
expectFilter(),
|
|
),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "org1",
|
|
storageKey: "key",
|
|
},
|
|
res: res{
|
|
err: caos_errs.IsNotFound,
|
|
},
|
|
},
|
|
{
|
|
name: "logo added, ok",
|
|
fields: fields{
|
|
storage: mock.NewMockStorage(gomock.NewController(t)).ExpectRemoveObjectNoError(),
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
expectFilter(
|
|
eventFromEventPusher(
|
|
org.NewLabelPolicyAddedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate,
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
true,
|
|
true,
|
|
true,
|
|
domain.LabelPolicyThemeAuto,
|
|
),
|
|
),
|
|
eventFromEventPusher(
|
|
org.NewLabelPolicyLogoAddedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate,
|
|
"key",
|
|
),
|
|
),
|
|
),
|
|
expectPush(
|
|
org.NewLabelPolicyLogoRemovedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate,
|
|
"key",
|
|
),
|
|
),
|
|
),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "org1",
|
|
storageKey: "key",
|
|
},
|
|
res: res{
|
|
want: &domain.ObjectDetails{
|
|
ResourceOwner: "org1",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
r := &Commands{
|
|
eventstore: tt.fields.eventstore,
|
|
static: tt.fields.storage,
|
|
}
|
|
got, err := r.RemoveLogoLabelPolicy(tt.args.ctx, tt.args.orgID)
|
|
if tt.res.err == nil {
|
|
assert.NoError(t, err)
|
|
}
|
|
if tt.res.err != nil && !tt.res.err(err) {
|
|
t.Errorf("got wrong err: %v ", err)
|
|
}
|
|
if tt.res.err == nil {
|
|
assert.Equal(t, tt.res.want, got)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCommandSide_AddIconLabelPolicy(t *testing.T) {
|
|
type fields struct {
|
|
eventstore *eventstore.Eventstore
|
|
storage static.Storage
|
|
}
|
|
type args struct {
|
|
ctx context.Context
|
|
orgID string
|
|
upload *AssetUpload
|
|
}
|
|
type res struct {
|
|
want *domain.ObjectDetails
|
|
err func(error) bool
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
fields fields
|
|
args args
|
|
res res
|
|
}{
|
|
{
|
|
name: "orgID empty, invalid argument error",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "",
|
|
upload: &AssetUpload{
|
|
ResourceOwner: "org1",
|
|
ObjectName: "icon",
|
|
ContentType: "image",
|
|
ObjectType: static.ObjectTypeStyling,
|
|
File: bytes.NewReader([]byte("test")),
|
|
Size: 4,
|
|
},
|
|
},
|
|
res: res{
|
|
err: caos_errs.IsErrorInvalidArgument,
|
|
},
|
|
},
|
|
{
|
|
name: "label policy not existing, not found error",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
expectFilter(),
|
|
),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "org1",
|
|
upload: &AssetUpload{
|
|
ResourceOwner: "org1",
|
|
ObjectName: "icon",
|
|
ContentType: "image",
|
|
ObjectType: static.ObjectTypeStyling,
|
|
File: bytes.NewReader([]byte("test")),
|
|
Size: 4,
|
|
},
|
|
},
|
|
res: res{
|
|
err: caos_errs.IsNotFound,
|
|
},
|
|
},
|
|
{
|
|
name: "upload failed, error",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
expectFilter(
|
|
eventFromEventPusher(
|
|
org.NewLabelPolicyAddedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate,
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
true,
|
|
true,
|
|
true,
|
|
domain.LabelPolicyThemeAuto,
|
|
),
|
|
),
|
|
),
|
|
),
|
|
storage: mock.NewStorage(t).ExpectPutObjectError(),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "org1",
|
|
upload: &AssetUpload{
|
|
ResourceOwner: "org1",
|
|
ObjectName: "icon",
|
|
ContentType: "image",
|
|
ObjectType: static.ObjectTypeStyling,
|
|
File: bytes.NewReader([]byte("test")),
|
|
Size: 4,
|
|
},
|
|
},
|
|
res: res{
|
|
err: caos_errs.IsInternal,
|
|
},
|
|
},
|
|
{
|
|
name: "icon added, ok",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
expectFilter(
|
|
eventFromEventPusher(
|
|
org.NewLabelPolicyAddedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate,
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
true,
|
|
true,
|
|
true,
|
|
domain.LabelPolicyThemeAuto,
|
|
),
|
|
),
|
|
),
|
|
expectPush(
|
|
org.NewLabelPolicyIconAddedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate,
|
|
"icon",
|
|
),
|
|
),
|
|
),
|
|
storage: mock.NewStorage(t).ExpectPutObject(),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "org1",
|
|
upload: &AssetUpload{
|
|
ResourceOwner: "org1",
|
|
ObjectName: "icon",
|
|
ContentType: "image",
|
|
ObjectType: static.ObjectTypeStyling,
|
|
File: bytes.NewReader([]byte("test")),
|
|
Size: 4,
|
|
},
|
|
},
|
|
res: res{
|
|
want: &domain.ObjectDetails{
|
|
ResourceOwner: "org1",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
r := &Commands{
|
|
eventstore: tt.fields.eventstore,
|
|
static: tt.fields.storage,
|
|
}
|
|
got, err := r.AddIconLabelPolicy(tt.args.ctx, tt.args.orgID, tt.args.upload)
|
|
if tt.res.err == nil {
|
|
assert.NoError(t, err)
|
|
}
|
|
if tt.res.err != nil && !tt.res.err(err) {
|
|
t.Errorf("got wrong err: %v ", err)
|
|
}
|
|
if tt.res.err == nil {
|
|
assert.Equal(t, tt.res.want, got)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCommandSide_RemoveIconLabelPolicy(t *testing.T) {
|
|
type fields struct {
|
|
eventstore *eventstore.Eventstore
|
|
storage static.Storage
|
|
}
|
|
type args struct {
|
|
ctx context.Context
|
|
orgID string
|
|
}
|
|
type res struct {
|
|
want *domain.ObjectDetails
|
|
err func(error) bool
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
fields fields
|
|
args args
|
|
res res
|
|
}{
|
|
{
|
|
name: "orgID empty, invalid argument error",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "",
|
|
},
|
|
res: res{
|
|
err: caos_errs.IsErrorInvalidArgument,
|
|
},
|
|
},
|
|
{
|
|
name: "label policy not existing, not found error",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
expectFilter(),
|
|
),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "org1",
|
|
},
|
|
res: res{
|
|
err: caos_errs.IsNotFound,
|
|
},
|
|
},
|
|
{
|
|
name: "icon added, ok",
|
|
fields: fields{
|
|
storage: mock.NewMockStorage(gomock.NewController(t)).ExpectRemoveObjectNoError(),
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
expectFilter(
|
|
eventFromEventPusher(
|
|
org.NewLabelPolicyAddedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate,
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
true,
|
|
true,
|
|
true,
|
|
domain.LabelPolicyThemeAuto,
|
|
),
|
|
),
|
|
eventFromEventPusher(
|
|
org.NewLabelPolicyIconAddedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate,
|
|
"key",
|
|
),
|
|
),
|
|
),
|
|
expectPush(
|
|
org.NewLabelPolicyIconRemovedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate,
|
|
"key",
|
|
),
|
|
),
|
|
),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "org1",
|
|
},
|
|
res: res{
|
|
want: &domain.ObjectDetails{
|
|
ResourceOwner: "org1",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
r := &Commands{
|
|
eventstore: tt.fields.eventstore,
|
|
static: tt.fields.storage,
|
|
}
|
|
got, err := r.RemoveIconLabelPolicy(tt.args.ctx, tt.args.orgID)
|
|
if tt.res.err == nil {
|
|
assert.NoError(t, err)
|
|
}
|
|
if tt.res.err != nil && !tt.res.err(err) {
|
|
t.Errorf("got wrong err: %v ", err)
|
|
}
|
|
if tt.res.err == nil {
|
|
assert.Equal(t, tt.res.want, got)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCommandSide_AddLogoDarkLabelPolicy(t *testing.T) {
|
|
type fields struct {
|
|
eventstore *eventstore.Eventstore
|
|
storage static.Storage
|
|
}
|
|
type args struct {
|
|
ctx context.Context
|
|
orgID string
|
|
upload *AssetUpload
|
|
}
|
|
type res struct {
|
|
want *domain.ObjectDetails
|
|
err func(error) bool
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
fields fields
|
|
args args
|
|
res res
|
|
}{
|
|
{
|
|
name: "orgID empty, invalid argument error",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "",
|
|
upload: &AssetUpload{
|
|
ResourceOwner: "org1",
|
|
ObjectName: "logo",
|
|
ContentType: "image",
|
|
ObjectType: static.ObjectTypeStyling,
|
|
File: bytes.NewReader([]byte("test")),
|
|
Size: 4,
|
|
},
|
|
},
|
|
res: res{
|
|
err: caos_errs.IsErrorInvalidArgument,
|
|
},
|
|
},
|
|
{
|
|
name: "label policy not existing, not found error",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
expectFilter(),
|
|
),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "org1",
|
|
upload: &AssetUpload{
|
|
ResourceOwner: "org1",
|
|
ObjectName: "logo",
|
|
ContentType: "image",
|
|
ObjectType: static.ObjectTypeStyling,
|
|
File: bytes.NewReader([]byte("test")),
|
|
Size: 4,
|
|
},
|
|
},
|
|
res: res{
|
|
err: caos_errs.IsNotFound,
|
|
},
|
|
},
|
|
{
|
|
name: "upload failed, error",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
expectFilter(
|
|
eventFromEventPusher(
|
|
org.NewLabelPolicyAddedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate,
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
true,
|
|
true,
|
|
true,
|
|
domain.LabelPolicyThemeAuto,
|
|
),
|
|
),
|
|
),
|
|
),
|
|
storage: mock.NewStorage(t).ExpectPutObjectError(),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "org1",
|
|
upload: &AssetUpload{
|
|
ResourceOwner: "org1",
|
|
ObjectName: "logo",
|
|
ContentType: "image",
|
|
ObjectType: static.ObjectTypeStyling,
|
|
File: bytes.NewReader([]byte("test")),
|
|
Size: 4,
|
|
},
|
|
},
|
|
res: res{
|
|
err: caos_errs.IsInternal,
|
|
},
|
|
},
|
|
{
|
|
name: "logo dark added, ok",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
expectFilter(
|
|
eventFromEventPusher(
|
|
org.NewLabelPolicyAddedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate,
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
true,
|
|
true,
|
|
true,
|
|
domain.LabelPolicyThemeAuto,
|
|
),
|
|
),
|
|
),
|
|
expectPush(
|
|
org.NewLabelPolicyLogoDarkAddedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate,
|
|
"logo",
|
|
),
|
|
),
|
|
),
|
|
storage: mock.NewStorage(t).ExpectPutObject(),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "org1",
|
|
upload: &AssetUpload{
|
|
ResourceOwner: "org1",
|
|
ObjectName: "logo",
|
|
ContentType: "image",
|
|
ObjectType: static.ObjectTypeStyling,
|
|
File: bytes.NewReader([]byte("test")),
|
|
Size: 4,
|
|
},
|
|
},
|
|
res: res{
|
|
want: &domain.ObjectDetails{
|
|
ResourceOwner: "org1",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
r := &Commands{
|
|
eventstore: tt.fields.eventstore,
|
|
static: tt.fields.storage,
|
|
}
|
|
got, err := r.AddLogoDarkLabelPolicy(tt.args.ctx, tt.args.orgID, tt.args.upload)
|
|
if tt.res.err == nil {
|
|
assert.NoError(t, err)
|
|
}
|
|
if tt.res.err != nil && !tt.res.err(err) {
|
|
t.Errorf("got wrong err: %v ", err)
|
|
}
|
|
if tt.res.err == nil {
|
|
assert.Equal(t, tt.res.want, got)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCommandSide_RemoveLogoDarkLabelPolicy(t *testing.T) {
|
|
type fields struct {
|
|
eventstore *eventstore.Eventstore
|
|
storage static.Storage
|
|
}
|
|
type args struct {
|
|
ctx context.Context
|
|
orgID string
|
|
storageKey string
|
|
}
|
|
type res struct {
|
|
want *domain.ObjectDetails
|
|
err func(error) bool
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
fields fields
|
|
args args
|
|
res res
|
|
}{
|
|
{
|
|
name: "orgID empty, invalid argument error",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
storageKey: "key",
|
|
},
|
|
res: res{
|
|
err: caos_errs.IsErrorInvalidArgument,
|
|
},
|
|
},
|
|
{
|
|
name: "label policy not existing, not found error",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
expectFilter(),
|
|
),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "org1",
|
|
storageKey: "key",
|
|
},
|
|
res: res{
|
|
err: caos_errs.IsNotFound,
|
|
},
|
|
},
|
|
{
|
|
name: "logo dark removed, ok",
|
|
fields: fields{
|
|
storage: mock.NewMockStorage(gomock.NewController(t)).ExpectRemoveObjectNoError(),
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
expectFilter(
|
|
eventFromEventPusher(
|
|
org.NewLabelPolicyAddedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate,
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
true,
|
|
true,
|
|
true,
|
|
domain.LabelPolicyThemeAuto,
|
|
),
|
|
),
|
|
eventFromEventPusher(
|
|
org.NewLabelPolicyLogoDarkAddedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate,
|
|
"key",
|
|
),
|
|
),
|
|
),
|
|
expectPush(
|
|
org.NewLabelPolicyLogoDarkRemovedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate,
|
|
"key",
|
|
),
|
|
),
|
|
),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "org1",
|
|
storageKey: "key",
|
|
},
|
|
res: res{
|
|
want: &domain.ObjectDetails{
|
|
ResourceOwner: "org1",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
r := &Commands{
|
|
eventstore: tt.fields.eventstore,
|
|
static: tt.fields.storage,
|
|
}
|
|
got, err := r.RemoveLogoDarkLabelPolicy(tt.args.ctx, tt.args.orgID)
|
|
if tt.res.err == nil {
|
|
assert.NoError(t, err)
|
|
}
|
|
if tt.res.err != nil && !tt.res.err(err) {
|
|
t.Errorf("got wrong err: %v ", err)
|
|
}
|
|
if tt.res.err == nil {
|
|
assert.Equal(t, tt.res.want, got)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCommandSide_AddIconDarkLabelPolicy(t *testing.T) {
|
|
type fields struct {
|
|
eventstore *eventstore.Eventstore
|
|
storage static.Storage
|
|
}
|
|
type args struct {
|
|
ctx context.Context
|
|
orgID string
|
|
upload *AssetUpload
|
|
}
|
|
type res struct {
|
|
want *domain.ObjectDetails
|
|
err func(error) bool
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
fields fields
|
|
args args
|
|
res res
|
|
}{
|
|
{
|
|
name: "orgID empty, invalid argument error",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "",
|
|
upload: &AssetUpload{
|
|
ResourceOwner: "org1",
|
|
ObjectName: "icon",
|
|
ContentType: "image",
|
|
ObjectType: static.ObjectTypeStyling,
|
|
File: bytes.NewReader([]byte("test")),
|
|
Size: 4,
|
|
},
|
|
},
|
|
res: res{
|
|
err: caos_errs.IsErrorInvalidArgument,
|
|
},
|
|
},
|
|
{
|
|
name: "label policy not existing, not found error",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
expectFilter(),
|
|
),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "org1",
|
|
upload: &AssetUpload{
|
|
ResourceOwner: "org1",
|
|
ObjectName: "icon",
|
|
ContentType: "image",
|
|
ObjectType: static.ObjectTypeStyling,
|
|
File: bytes.NewReader([]byte("test")),
|
|
Size: 4,
|
|
},
|
|
},
|
|
res: res{
|
|
err: caos_errs.IsNotFound,
|
|
},
|
|
},
|
|
{
|
|
name: "upload failed, error",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
expectFilter(
|
|
eventFromEventPusher(
|
|
org.NewLabelPolicyAddedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate,
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
true,
|
|
true,
|
|
true,
|
|
domain.LabelPolicyThemeAuto,
|
|
),
|
|
),
|
|
),
|
|
),
|
|
storage: mock.NewStorage(t).ExpectPutObjectError(),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "org1",
|
|
upload: &AssetUpload{
|
|
ResourceOwner: "org1",
|
|
ObjectName: "icon",
|
|
ContentType: "image",
|
|
ObjectType: static.ObjectTypeStyling,
|
|
File: bytes.NewReader([]byte("test")),
|
|
Size: 4,
|
|
},
|
|
},
|
|
res: res{
|
|
err: caos_errs.IsInternal,
|
|
},
|
|
},
|
|
{
|
|
name: "icon dark added, ok",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
expectFilter(
|
|
eventFromEventPusher(
|
|
org.NewLabelPolicyAddedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate,
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
true,
|
|
true,
|
|
true,
|
|
domain.LabelPolicyThemeAuto,
|
|
),
|
|
),
|
|
),
|
|
expectPush(
|
|
org.NewLabelPolicyIconDarkAddedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate,
|
|
"icon",
|
|
),
|
|
),
|
|
),
|
|
storage: mock.NewStorage(t).ExpectPutObject(),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "org1",
|
|
upload: &AssetUpload{
|
|
ResourceOwner: "org1",
|
|
ObjectName: "icon",
|
|
ContentType: "image",
|
|
ObjectType: static.ObjectTypeStyling,
|
|
File: bytes.NewReader([]byte("test")),
|
|
Size: 4,
|
|
},
|
|
},
|
|
res: res{
|
|
want: &domain.ObjectDetails{
|
|
ResourceOwner: "org1",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
r := &Commands{
|
|
eventstore: tt.fields.eventstore,
|
|
static: tt.fields.storage,
|
|
}
|
|
got, err := r.AddIconDarkLabelPolicy(tt.args.ctx, tt.args.orgID, tt.args.upload)
|
|
if tt.res.err == nil {
|
|
assert.NoError(t, err)
|
|
}
|
|
if tt.res.err != nil && !tt.res.err(err) {
|
|
t.Errorf("got wrong err: %v ", err)
|
|
}
|
|
if tt.res.err == nil {
|
|
assert.Equal(t, tt.res.want, got)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCommandSide_RemoveIconDarkLabelPolicy(t *testing.T) {
|
|
type fields struct {
|
|
eventstore *eventstore.Eventstore
|
|
storage static.Storage
|
|
}
|
|
type args struct {
|
|
ctx context.Context
|
|
orgID string
|
|
}
|
|
type res struct {
|
|
want *domain.ObjectDetails
|
|
err func(error) bool
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
fields fields
|
|
args args
|
|
res res
|
|
}{
|
|
{
|
|
name: "orgID empty, invalid argument error",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
},
|
|
res: res{
|
|
err: caos_errs.IsErrorInvalidArgument,
|
|
},
|
|
},
|
|
{
|
|
name: "label policy not existing, not found error",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
expectFilter(),
|
|
),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "org1",
|
|
},
|
|
res: res{
|
|
err: caos_errs.IsNotFound,
|
|
},
|
|
},
|
|
{
|
|
name: "icon dark added, ok",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
expectFilter(
|
|
eventFromEventPusher(
|
|
org.NewLabelPolicyAddedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate,
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
true,
|
|
true,
|
|
true,
|
|
domain.LabelPolicyThemeAuto,
|
|
),
|
|
),
|
|
eventFromEventPusher(
|
|
org.NewLabelPolicyIconDarkAddedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate,
|
|
"key",
|
|
),
|
|
),
|
|
),
|
|
expectPush(
|
|
org.NewLabelPolicyIconDarkRemovedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate,
|
|
"key",
|
|
),
|
|
),
|
|
),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "org1",
|
|
},
|
|
res: res{
|
|
want: &domain.ObjectDetails{
|
|
ResourceOwner: "org1",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
r := &Commands{
|
|
eventstore: tt.fields.eventstore,
|
|
static: tt.fields.storage,
|
|
}
|
|
got, err := r.RemoveIconDarkLabelPolicy(tt.args.ctx, tt.args.orgID)
|
|
if tt.res.err == nil {
|
|
assert.NoError(t, err)
|
|
}
|
|
if tt.res.err != nil && !tt.res.err(err) {
|
|
t.Errorf("got wrong err: %v ", err)
|
|
}
|
|
if tt.res.err == nil {
|
|
assert.Equal(t, tt.res.want, got)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCommandSide_AddFontLabelPolicy(t *testing.T) {
|
|
type fields struct {
|
|
eventstore *eventstore.Eventstore
|
|
storage static.Storage
|
|
}
|
|
type args struct {
|
|
ctx context.Context
|
|
orgID string
|
|
upload *AssetUpload
|
|
}
|
|
type res struct {
|
|
want *domain.ObjectDetails
|
|
err func(error) bool
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
fields fields
|
|
args args
|
|
res res
|
|
}{
|
|
{
|
|
name: "orgID empty, invalid argument error",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "",
|
|
upload: &AssetUpload{
|
|
ResourceOwner: "org1",
|
|
ObjectName: "font",
|
|
ContentType: "ttf",
|
|
ObjectType: static.ObjectTypeStyling,
|
|
File: bytes.NewReader([]byte("test")),
|
|
Size: 4,
|
|
},
|
|
},
|
|
res: res{
|
|
err: caos_errs.IsErrorInvalidArgument,
|
|
},
|
|
},
|
|
{
|
|
name: "label policy not existing, not found error",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
expectFilter(),
|
|
),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "org1",
|
|
},
|
|
res: res{
|
|
err: caos_errs.IsNotFound,
|
|
},
|
|
},
|
|
{
|
|
name: "upload failed, error",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
expectFilter(
|
|
eventFromEventPusher(
|
|
org.NewLabelPolicyAddedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate,
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
true,
|
|
true,
|
|
true,
|
|
domain.LabelPolicyThemeAuto,
|
|
),
|
|
),
|
|
),
|
|
),
|
|
storage: mock.NewStorage(t).ExpectPutObjectError(),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "org1",
|
|
upload: &AssetUpload{
|
|
ResourceOwner: "org1",
|
|
ObjectName: "font",
|
|
ContentType: "ttf",
|
|
ObjectType: static.ObjectTypeStyling,
|
|
File: bytes.NewReader([]byte("test")),
|
|
Size: 4,
|
|
},
|
|
},
|
|
res: res{
|
|
err: caos_errs.IsInternal,
|
|
},
|
|
},
|
|
{
|
|
name: "font added, ok",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
expectFilter(
|
|
eventFromEventPusher(
|
|
org.NewLabelPolicyAddedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate,
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
true,
|
|
true,
|
|
true,
|
|
domain.LabelPolicyThemeAuto,
|
|
),
|
|
),
|
|
),
|
|
expectPush(
|
|
org.NewLabelPolicyFontAddedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate,
|
|
"font",
|
|
),
|
|
),
|
|
),
|
|
storage: mock.NewStorage(t).ExpectPutObject(),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "org1",
|
|
upload: &AssetUpload{
|
|
ResourceOwner: "org1",
|
|
ObjectName: "font",
|
|
ContentType: "ttf",
|
|
ObjectType: static.ObjectTypeStyling,
|
|
File: bytes.NewReader([]byte("test")),
|
|
Size: 4,
|
|
},
|
|
},
|
|
res: res{
|
|
want: &domain.ObjectDetails{
|
|
ResourceOwner: "org1",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
r := &Commands{
|
|
eventstore: tt.fields.eventstore,
|
|
static: tt.fields.storage,
|
|
}
|
|
got, err := r.AddFontLabelPolicy(tt.args.ctx, tt.args.orgID, tt.args.upload)
|
|
if tt.res.err == nil {
|
|
assert.NoError(t, err)
|
|
}
|
|
if tt.res.err != nil && !tt.res.err(err) {
|
|
t.Errorf("got wrong err: %v ", err)
|
|
}
|
|
if tt.res.err == nil {
|
|
assert.Equal(t, tt.res.want, got)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCommandSide_RemoveFontLabelPolicy(t *testing.T) {
|
|
type fields struct {
|
|
eventstore *eventstore.Eventstore
|
|
storage static.Storage
|
|
}
|
|
type args struct {
|
|
ctx context.Context
|
|
orgID string
|
|
}
|
|
type res struct {
|
|
want *domain.ObjectDetails
|
|
err func(error) bool
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
fields fields
|
|
args args
|
|
res res
|
|
}{
|
|
{
|
|
name: "orgID empty, invalid argument error",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
},
|
|
res: res{
|
|
err: caos_errs.IsErrorInvalidArgument,
|
|
},
|
|
},
|
|
{
|
|
name: "label policy not existing, not found error",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
expectFilter(),
|
|
),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "org1",
|
|
},
|
|
res: res{
|
|
err: caos_errs.IsNotFound,
|
|
},
|
|
},
|
|
{
|
|
name: "font added, ok",
|
|
fields: fields{
|
|
eventstore: eventstoreExpect(
|
|
t,
|
|
expectFilter(
|
|
eventFromEventPusher(
|
|
org.NewLabelPolicyAddedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate,
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
"#ffffff",
|
|
true,
|
|
true,
|
|
true,
|
|
domain.LabelPolicyThemeAuto,
|
|
),
|
|
),
|
|
eventFromEventPusher(
|
|
org.NewLabelPolicyFontAddedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate,
|
|
"key",
|
|
),
|
|
),
|
|
),
|
|
expectPush(
|
|
org.NewLabelPolicyFontRemovedEvent(context.Background(),
|
|
&org.NewAggregate("org1").Aggregate,
|
|
"key",
|
|
),
|
|
),
|
|
),
|
|
},
|
|
args: args{
|
|
ctx: context.Background(),
|
|
orgID: "org1",
|
|
},
|
|
res: res{
|
|
want: &domain.ObjectDetails{
|
|
ResourceOwner: "org1",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
r := &Commands{
|
|
eventstore: tt.fields.eventstore,
|
|
static: tt.fields.storage,
|
|
}
|
|
got, err := r.RemoveFontLabelPolicy(tt.args.ctx, tt.args.orgID)
|
|
if tt.res.err == nil {
|
|
assert.NoError(t, err)
|
|
}
|
|
if tt.res.err != nil && !tt.res.err(err) {
|
|
t.Errorf("got wrong err: %v ", err)
|
|
}
|
|
if tt.res.err == nil {
|
|
assert.Equal(t, tt.res.want, got)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func newLabelPolicyChangedEvent(ctx context.Context, orgID, primaryColor, backgroundColor, warnColor, fontColor, primaryColorDark, backgroundColorDark, warnColorDark, fontColorDark string, hideLoginNameSuffix, errMsgPopup, disableWatermark bool, theme domain.LabelPolicyThemeMode) *org.LabelPolicyChangedEvent {
|
|
event, _ := org.NewLabelPolicyChangedEvent(ctx,
|
|
&org.NewAggregate(orgID).Aggregate,
|
|
[]policy.LabelPolicyChanges{
|
|
policy.ChangePrimaryColor(primaryColor),
|
|
policy.ChangeBackgroundColor(backgroundColor),
|
|
policy.ChangeWarnColor(warnColor),
|
|
policy.ChangeFontColor(fontColor),
|
|
policy.ChangePrimaryColorDark(primaryColorDark),
|
|
policy.ChangeBackgroundColorDark(backgroundColorDark),
|
|
policy.ChangeWarnColorDark(warnColorDark),
|
|
policy.ChangeFontColorDark(fontColorDark),
|
|
policy.ChangeHideLoginNameSuffix(hideLoginNameSuffix),
|
|
policy.ChangeErrorMsgPopup(errMsgPopup),
|
|
policy.ChangeDisableWatermark(disableWatermark),
|
|
policy.ChangeThemeMode(theme),
|
|
},
|
|
)
|
|
return event
|
|
}
|