Skip to content

Commit

Permalink
#55 Add unit tests
Browse files Browse the repository at this point in the history
  • Loading branch information
@nhinze23
nhinze23 committed Mar 8, 2024
1 parent 68e20dc commit 9bf2909
Show file tree
Hide file tree
Showing 7 changed files with 353 additions and 33 deletions.
2 changes: 1 addition & 1 deletion pkg/adapter/kubernetes/blueprintcr/v1/doguDiff.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -70,7 +70,7 @@ func convertToDoguDiffDTO(domainModel domain.DoguDiff) DoguDiff {
MinVolumeSize: ecosystem.GetQuantityString(domainModel.Expected.MinVolumeSize),
},
ReverseProxyConfig: ReverseProxyConfig{
MaxBodySize: ecosystem.GetQuantityString(domainModel.Actual.ReverseProxyConfig.MaxBodySize),
MaxBodySize: ecosystem.GetQuantityString(domainModel.Expected.ReverseProxyConfig.MaxBodySize),
RewriteTarget: string(domainModel.Expected.ReverseProxyConfig.RewriteTarget),
AdditionalConfig: string(domainModel.Expected.ReverseProxyConfig.AdditionalConfig),
},
Expand Down
2 changes: 2 additions & 0 deletions pkg/adapter/serializer/targetDogu.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -66,12 +66,14 @@ func ConvertDogus(dogus []TargetDogu) ([]domain.Dogu, error) {
minVolumeSize, minVolumeSizeErr := ecosystem.GetQuantityReference(minVolumeSizeStr)
if minVolumeSizeErr != nil {
errorList = append(errorList, fmt.Errorf("could not parse minimum volume size %q for dogu %q", minVolumeSizeStr, dogu.Name))
continue
}

maxBodySizeStr := dogu.PlatformConfig.ReverseProxyConfig.MaxBodySize
maxBodySize, maxBodySizeErr := ecosystem.GetQuantityReference(maxBodySizeStr)
if maxBodySizeErr != nil {
errorList = append(errorList, fmt.Errorf("could not parse maximum proxy body size %q for dogu %q", maxBodySizeStr, dogu.Name))
continue
}

convertedDogus = append(convertedDogus, domain.Dogu{
Expand Down
66 changes: 48 additions & 18 deletions pkg/adapter/serializer/targetDogu_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -5,7 +5,9 @@ import (
"github.com/cloudogu/cesapp-lib/core"
"github.com/cloudogu/k8s-blueprint-operator/pkg/domain"
"github.com/cloudogu/k8s-blueprint-operator/pkg/domain/common"
"github.com/cloudogu/k8s-blueprint-operator/pkg/domain/ecosystem"
"github.com/stretchr/testify/assert"
"k8s.io/apimachinery/pkg/api/resource"
"testing"
)

Expand All @@ -17,6 +19,8 @@ func TestConvertDogus(t *testing.T) {
type args struct {
dogus []TargetDogu
}
proxyBodySize := resource.MustParse("1G")
volumeSize := resource.MustParse("1Gi")
tests := []struct {
name string
args args
Expand All @@ -41,18 +45,42 @@ func TestConvertDogus(t *testing.T) {
want: []domain.Dogu{{Name: common.QualifiedDoguName{Namespace: "official", SimpleName: "postgres"}, Version: version3211, TargetState: domain.TargetStatePresent}},
wantErr: assert.NoError,
},
// {
// name: "dogu with max proxy body size",
// args: args{dogus: []TargetDogu{{Name: "official/postgres", Version: version3211.Raw, TargetState: "present", PlatformConfig: PlatformConfig{ReverseProxyConfig: ReverseProxyConfig{MaxBodySize: "1.2G"}}}}},
// want: []domain.Dogu{{Name: common.QualifiedDoguName{Namespace: "official", SimpleName: "postgres"}, Version: version3211, TargetState: domain.TargetStatePresent, ReverseProxyConfig: ecosystem.ReverseProxyConfig{MaxBodySize: resource.MustParse("1200M")}}},
// wantErr: assert.NoError,
// },
// {
// name: "dogu with max proxy body size should converted to decimal prefix",
// args: args{dogus: []TargetDogu{{Name: "official/postgres", Version: version3211.Raw, TargetState: "present", PlatformConfig: PlatformConfig{ReverseProxyConfig: ReverseProxyConfig{MaxBodySize: "1Gi"}}}}},
// want: []domain.Dogu{{Name: common.QualifiedDoguName{Namespace: "official", SimpleName: "postgres"}, Version: version3211, TargetState: domain.TargetStatePresent, ReverseProxyConfig: ecosystem.ReverseProxyConfig{MaxBodySize: resource.MustParse("1073.74M")}}},
// wantErr: assert.NoError,
// },
{
name: "dogu with max proxy body size",
args: args{dogus: []TargetDogu{{Name: "official/postgres", Version: version3211.Raw, TargetState: "present", PlatformConfig: PlatformConfig{ReverseProxyConfig: ReverseProxyConfig{MaxBodySize: "1G"}}}}},
want: []domain.Dogu{{Name: common.QualifiedDoguName{Namespace: "official", SimpleName: "postgres"}, Version: version3211, TargetState: domain.TargetStatePresent, ReverseProxyConfig: ecosystem.ReverseProxyConfig{MaxBodySize: &proxyBodySize}}},
wantErr: assert.NoError,
},
{
name: "dogu with proxy rewrite target",
args: args{dogus: []TargetDogu{{Name: "official/postgres", Version: version3211.Raw, TargetState: "present", PlatformConfig: PlatformConfig{ReverseProxyConfig: ReverseProxyConfig{RewriteTarget: "/"}}}}},
want: []domain.Dogu{{Name: common.QualifiedDoguName{Namespace: "official", SimpleName: "postgres"}, Version: version3211, TargetState: domain.TargetStatePresent, ReverseProxyConfig: ecosystem.ReverseProxyConfig{RewriteTarget: "/"}}},
wantErr: assert.NoError,
},
{
name: "dogu with proxy additional config",
args: args{dogus: []TargetDogu{{Name: "official/postgres", Version: version3211.Raw, TargetState: "present", PlatformConfig: PlatformConfig{ReverseProxyConfig: ReverseProxyConfig{AdditionalConfig: "additional"}}}}},
want: []domain.Dogu{{Name: common.QualifiedDoguName{Namespace: "official", SimpleName: "postgres"}, Version: version3211, TargetState: domain.TargetStatePresent, ReverseProxyConfig: ecosystem.ReverseProxyConfig{AdditionalConfig: "additional"}}},
wantErr: assert.NoError,
},
{
name: "dogu with invalid proxy body size",
args: args{dogus: []TargetDogu{{Name: "official/postgres", Version: version3211.Raw, TargetState: "present", PlatformConfig: PlatformConfig{ReverseProxyConfig: ReverseProxyConfig{MaxBodySize: "1GE"}}}}},
want: nil,
wantErr: assert.Error,
},
{
name: "dogu with min volume size",
args: args{dogus: []TargetDogu{{Name: "official/postgres", Version: version3211.Raw, TargetState: "present", PlatformConfig: PlatformConfig{ResourceConfig: ResourceConfig{MinVolumeSize: "1Gi"}}}}},
want: []domain.Dogu{{Name: common.QualifiedDoguName{Namespace: "official", SimpleName: "postgres"}, Version: version3211, TargetState: domain.TargetStatePresent, MinVolumeSize: &volumeSize}},
wantErr: assert.NoError,
},
{
name: "dogu with invalid volume size",
args: args{dogus: []TargetDogu{{Name: "official/postgres", Version: version3211.Raw, TargetState: "present", PlatformConfig: PlatformConfig{ResourceConfig: ResourceConfig{MinVolumeSize: "1GIE"}}}}},
want: nil,
wantErr: assert.Error,
},
{
name: "no namespace",
args: args{dogus: []TargetDogu{{Name: "postgres", Version: version3211.Raw, TargetState: "present"}}},
Expand Down Expand Up @@ -87,6 +115,8 @@ func TestConvertToDoguDTOs(t *testing.T) {
type args struct {
dogus []domain.Dogu
}
bodySize := resource.MustParse("100M")
volumeSize := resource.MustParse("1G")
tests := []struct {
name string
args args
Expand All @@ -105,12 +135,12 @@ func TestConvertToDoguDTOs(t *testing.T) {
want: []TargetDogu{},
wantErr: assert.NoError,
},
// {
// name: "ok",
// args: args{dogus: []domain.Dogu{{Name: common.QualifiedDoguName{Namespace: "official", SimpleName: "postgres"}, Version: version3211, TargetState: domain.TargetStatePresent, ReverseProxyConfig: ecosystem.ReverseProxyConfig{MaxBodySize: resource.MustParse("100M")}}}},
// want: []TargetDogu{{Name: "official/postgres", Version: version3211.Raw, TargetState: "present", PlatformConfig: PlatformConfig{ReverseProxyConfig: ReverseProxyConfig{MaxBodySize: "100M"}}}},
// wantErr: assert.NoError,
// },
{
name: "ok",
args: args{dogus: []domain.Dogu{{Name: common.QualifiedDoguName{Namespace: "official", SimpleName: "postgres"}, Version: version3211, TargetState: domain.TargetStatePresent, MinVolumeSize: &volumeSize, ReverseProxyConfig: ecosystem.ReverseProxyConfig{MaxBodySize: &bodySize, RewriteTarget: "/", AdditionalConfig: "additional"}}}},
want: []TargetDogu{{Name: "official/postgres", Version: version3211.Raw, TargetState: "present", PlatformConfig: PlatformConfig{ResourceConfig: ResourceConfig{MinVolumeSize: "1G"}, ReverseProxyConfig: ReverseProxyConfig{MaxBodySize: "100M", RewriteTarget: "/", AdditionalConfig: "additional"}}}},
wantErr: assert.NoError,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
Expand Down
250 changes: 250 additions & 0 deletions pkg/application/doguInstallationUseCase_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -179,6 +179,234 @@ func TestDoguInstallationUseCase_applyDoguState(t *testing.T) {
assert.Equal(t, version3212, dogu.Version)
})

t.Run("action update volume size", func(t *testing.T) {
volumeSize := resource.MustParse("2Gi")
expectedVolumeSize := resource.MustParse("3Gi")
expectedDogu := &ecosystem.DoguInstallation{
Name: postgresqlQualifiedName,
MinVolumeSize: &expectedVolumeSize,
}

dogu := &ecosystem.DoguInstallation{
Name: postgresqlQualifiedName,
MinVolumeSize: &volumeSize,
}

doguRepoMock := newMockDoguInstallationRepository(t)
doguRepoMock.EXPECT().Update(testCtx, expectedDogu).Return(nil)

sut := NewDoguInstallationUseCase(nil, doguRepoMock, nil)

// when
err := sut.applyDoguState(
testCtx,
domain.DoguDiff{
DoguName: "postgresql",
Expected: domain.DoguDiffState{
MinVolumeSize: &expectedVolumeSize,
},
NeededActions: []domain.Action{domain.ActionUpdateDoguResourceMinVolumeSize},
},
dogu,
domain.BlueprintConfiguration{},
)

// then
require.NoError(t, err)
})

t.Run("action update proxy body size", func(t *testing.T) {
proxyBodySize := resource.MustParse("2G")
expectedProxyBodySize := resource.MustParse("3G")
expectedDogu := &ecosystem.DoguInstallation{
Name: postgresqlQualifiedName,
ReverseProxyConfig: ecosystem.ReverseProxyConfig{
MaxBodySize: &expectedProxyBodySize,
},
}

dogu := &ecosystem.DoguInstallation{
Name: postgresqlQualifiedName,
ReverseProxyConfig: ecosystem.ReverseProxyConfig{
MaxBodySize: &proxyBodySize,
},
}

doguRepoMock := newMockDoguInstallationRepository(t)
doguRepoMock.EXPECT().Update(testCtx, expectedDogu).Return(nil)

sut := NewDoguInstallationUseCase(nil, doguRepoMock, nil)

// when
err := sut.applyDoguState(
testCtx,
domain.DoguDiff{
DoguName: "postgresql",
Expected: domain.DoguDiffState{
ReverseProxyConfig: ecosystem.ReverseProxyConfig{
MaxBodySize: &expectedProxyBodySize,
},
},
NeededActions: []domain.Action{domain.ActionUpdateDoguProxyBodySize},
},
dogu,
domain.BlueprintConfiguration{},
)

// then
require.NoError(t, err)
})

t.Run("action update proxy rewrite target", func(t *testing.T) {
target := ecosystem.RewriteTarget("")
expectedTarget := ecosystem.RewriteTarget("/")
expectedDogu := &ecosystem.DoguInstallation{
Name: postgresqlQualifiedName,
ReverseProxyConfig: ecosystem.ReverseProxyConfig{
RewriteTarget: expectedTarget,
},
}

dogu := &ecosystem.DoguInstallation{
Name: postgresqlQualifiedName,
ReverseProxyConfig: ecosystem.ReverseProxyConfig{
RewriteTarget: target,
},
}

doguRepoMock := newMockDoguInstallationRepository(t)
doguRepoMock.EXPECT().Update(testCtx, expectedDogu).Return(nil)

sut := NewDoguInstallationUseCase(nil, doguRepoMock, nil)

// when
err := sut.applyDoguState(
testCtx,
domain.DoguDiff{
DoguName: "postgresql",
Expected: domain.DoguDiffState{
ReverseProxyConfig: ecosystem.ReverseProxyConfig{
RewriteTarget: expectedTarget,
},
},
NeededActions: []domain.Action{domain.ActionUpdateDoguProxyRewriteTarget},
},
dogu,
domain.BlueprintConfiguration{},
)

// then
require.NoError(t, err)
})

t.Run("action update proxy additional config", func(t *testing.T) {
additionalConfig := ecosystem.AdditionalConfig("")
expectedAdditionalConfig := ecosystem.AdditionalConfig("snippet")
expectedDogu := &ecosystem.DoguInstallation{
Name: postgresqlQualifiedName,
ReverseProxyConfig: ecosystem.ReverseProxyConfig{
AdditionalConfig: expectedAdditionalConfig,
},
}

dogu := &ecosystem.DoguInstallation{
Name: postgresqlQualifiedName,
ReverseProxyConfig: ecosystem.ReverseProxyConfig{
AdditionalConfig: additionalConfig,
},
}

doguRepoMock := newMockDoguInstallationRepository(t)
doguRepoMock.EXPECT().Update(testCtx, expectedDogu).Return(nil)

sut := NewDoguInstallationUseCase(nil, doguRepoMock, nil)

// when
err := sut.applyDoguState(
testCtx,
domain.DoguDiff{
DoguName: "postgresql",
Expected: domain.DoguDiffState{
ReverseProxyConfig: ecosystem.ReverseProxyConfig{
AdditionalConfig: expectedAdditionalConfig,
},
},
NeededActions: []domain.Action{domain.ActionUpdateDoguProxyAdditionalConfig},
},
dogu,
domain.BlueprintConfiguration{},
)

// then
require.NoError(t, err)
})

t.Run("should process multiple update actions", func(t *testing.T) {
volumeSize := resource.MustParse("2Gi")
expectedVolumeSize := resource.MustParse("3Gi")
proxyBodySize := resource.MustParse("2G")
expectedProxyBodySize := resource.MustParse("3G")
target := ecosystem.RewriteTarget("")
expectedTarget := ecosystem.RewriteTarget("/")
additionalConfig := ecosystem.AdditionalConfig("")
expectedAdditionalConfig := ecosystem.AdditionalConfig("snippet")
expectedDogu := &ecosystem.DoguInstallation{
Name: postgresqlQualifiedName,
Version: version3212,
MinVolumeSize: &expectedVolumeSize,
ReverseProxyConfig: ecosystem.ReverseProxyConfig{
MaxBodySize: &expectedProxyBodySize,
RewriteTarget: expectedTarget,
AdditionalConfig: expectedAdditionalConfig,
},
}

dogu := &ecosystem.DoguInstallation{
Name: postgresqlQualifiedName,
Version: version3211,
MinVolumeSize: &volumeSize,
ReverseProxyConfig: ecosystem.ReverseProxyConfig{
MaxBodySize: &proxyBodySize,
RewriteTarget: target,
AdditionalConfig: additionalConfig,
},
}

doguRepoMock := newMockDoguInstallationRepository(t)
doguRepoMock.EXPECT().Update(testCtx, expectedDogu).Return(nil)

sut := NewDoguInstallationUseCase(nil, doguRepoMock, nil)

// when
err := sut.applyDoguState(
testCtx,
domain.DoguDiff{
DoguName: "postgresql",
Expected: domain.DoguDiffState{
Version: version3212,
MinVolumeSize: &expectedVolumeSize,
ReverseProxyConfig: ecosystem.ReverseProxyConfig{
MaxBodySize: &expectedProxyBodySize,
RewriteTarget: expectedTarget,
AdditionalConfig: expectedAdditionalConfig,
},
},
NeededActions: []domain.Action{
domain.ActionUpgrade,
domain.ActionUpdateDoguProxyAdditionalConfig,
domain.ActionUpdateDoguProxyBodySize,
domain.ActionUpdateDoguProxyRewriteTarget,
domain.ActionUpdateDoguResourceMinVolumeSize,
},
},
dogu,
domain.BlueprintConfiguration{},
)

// then
require.NoError(t, err)
})

t.Run("action SwitchNamespace not allowed", func(t *testing.T) {
dogu := &ecosystem.DoguInstallation{
Name: postgresqlQualifiedName,
Expand Down Expand Up @@ -260,6 +488,28 @@ func TestDoguInstallationUseCase_applyDoguState(t *testing.T) {
require.ErrorContains(t, err, "cannot perform unknown action \"unknown\"")
})

t.Run("should fail with no actions", func(t *testing.T) {
// given
sut := NewDoguInstallationUseCase(nil, nil, nil)

// when
err := sut.applyDoguState(
testCtx,
domain.DoguDiff{
DoguName: "postgresql",
Expected: domain.DoguDiffState{
Namespace: "premium",
},
NeededActions: []domain.Action{},
},
nil,
domain.BlueprintConfiguration{},
)

// then
require.Error(t, err)
assert.ErrorContains(t, err, "fail because the total amount of actions is zero. actions should contain at least action \"none\" if nothing changed")
})
}

func TestDoguInstallationUseCase_ApplyDoguStates(t *testing.T) {
Expand Down
Loading

0 comments on commit 9bf2909

Please sign in to comment.