From 661ebf707e7adf52acd5fdd8d83a426d002b2d85 Mon Sep 17 00:00:00 2001 From: Markus Pesch Date: Mon, 24 Jul 2023 09:04:52 +0200 Subject: [PATCH] fix: rename package --- {pki => pkg}/domain/dockerCompose/config.go | 0 pkg/domain/dockerCompose/config_test.go | 434 ++++++++++++++++++ .../domain/dockerCompose/equalable.go | 0 pki/domain/dockerCompose/config_test.go | 2 +- 4 files changed, 435 insertions(+), 1 deletion(-) rename {pki => pkg}/domain/dockerCompose/config.go (100%) create mode 100644 pkg/domain/dockerCompose/config_test.go rename {pki => pkg}/domain/dockerCompose/equalable.go (100%) diff --git a/pki/domain/dockerCompose/config.go b/pkg/domain/dockerCompose/config.go similarity index 100% rename from pki/domain/dockerCompose/config.go rename to pkg/domain/dockerCompose/config.go diff --git a/pkg/domain/dockerCompose/config_test.go b/pkg/domain/dockerCompose/config_test.go new file mode 100644 index 0000000..357a659 --- /dev/null +++ b/pkg/domain/dockerCompose/config_test.go @@ -0,0 +1,434 @@ +package dockerCompose_test + +import ( + "testing" + + "git.cryptic.systems/volker.raschek/dcmerge/pki/domain/dockerCompose" + "github.com/stretchr/testify/require" +) + +func TestNetwork_Equal(t *testing.T) { + require := require.New(t) + + testCases := []struct { + equalableA dockerCompose.Equalable + equalableB dockerCompose.Equalable + expectedResult bool + }{ + { + equalableA: &dockerCompose.Network{ + External: true, + }, + equalableB: &dockerCompose.NetworkIPAM{}, + expectedResult: false, + }, + { + equalableA: &dockerCompose.Network{ + External: true, + }, + equalableB: nil, + expectedResult: false, + }, + { + equalableA: &dockerCompose.Network{ + External: false, + Driver: "bridge", + IPAM: nil, + }, + equalableB: &dockerCompose.Network{ + External: false, + Driver: "bridge", + IPAM: nil, + }, + expectedResult: true, + }, + { + equalableA: &dockerCompose.Network{ + External: false, + Driver: "host", + IPAM: nil, + }, + equalableB: &dockerCompose.Network{ + External: false, + Driver: "bride", + IPAM: nil, + }, + expectedResult: false, + }, + { + equalableA: &dockerCompose.Network{ + External: true, + Driver: "bridge", + IPAM: nil, + }, + equalableB: &dockerCompose.Network{ + External: false, + Driver: "bridge", + IPAM: nil, + }, + expectedResult: false, + }, + } + + for i, testCase := range testCases { + require.Equal(testCase.expectedResult, testCase.equalableA.Equal(testCase.equalableB), "Failed test case %v", i) + } +} + +func TestServiceDeployResourcesLimits_Equal(t *testing.T) { + require := require.New(t) + + testCases := []struct { + equalableA dockerCompose.Equalable + equalableB dockerCompose.Equalable + expectedResult bool + }{ + { + equalableA: &dockerCompose.ServiceDeployResourcesLimits{ + CPUs: "1", + Memory: "500", + }, + equalableB: &dockerCompose.NetworkIPAM{}, + expectedResult: false, + }, + { + equalableA: &dockerCompose.ServiceDeployResourcesLimits{ + CPUs: "1", + Memory: "500", + }, + equalableB: nil, + expectedResult: false, + }, + { + equalableA: &dockerCompose.ServiceDeployResourcesLimits{ + CPUs: "1", + Memory: "500", + }, + equalableB: &dockerCompose.ServiceDeployResourcesLimits{ + CPUs: "1", + Memory: "500", + }, + expectedResult: true, + }, + { + equalableA: &dockerCompose.ServiceDeployResourcesLimits{ + CPUs: "1", + }, + equalableB: &dockerCompose.ServiceDeployResourcesLimits{ + CPUs: "2", + }, + expectedResult: false, + }, + { + equalableA: &dockerCompose.ServiceDeployResourcesLimits{ + Memory: "500", + }, + equalableB: &dockerCompose.ServiceDeployResourcesLimits{ + Memory: "1000", + }, + expectedResult: false, + }, + } + + for i, testCase := range testCases { + require.Equal(testCase.expectedResult, testCase.equalableA.Equal(testCase.equalableB), "Failed test case %v", i) + } +} + +func TestServiceDeployResourcesLimits_MergeLastWin(t *testing.T) { + require := require.New(t) + + testCases := []struct { + serviceDeploymentResourcesLimitsA *dockerCompose.ServiceDeployResourcesLimits + serviceDeploymentResourcesLimitsB *dockerCompose.ServiceDeployResourcesLimits + expectedResult *dockerCompose.ServiceDeployResourcesLimits + }{ + { + serviceDeploymentResourcesLimitsA: nil, + serviceDeploymentResourcesLimitsB: nil, + expectedResult: nil, + }, + { + serviceDeploymentResourcesLimitsA: &dockerCompose.ServiceDeployResourcesLimits{ + CPUs: "1", + Memory: "500", + }, + serviceDeploymentResourcesLimitsB: nil, + expectedResult: &dockerCompose.ServiceDeployResourcesLimits{ + CPUs: "1", + Memory: "500", + }, + }, + { + serviceDeploymentResourcesLimitsA: &dockerCompose.ServiceDeployResourcesLimits{ + CPUs: "1", + Memory: "500", + }, + serviceDeploymentResourcesLimitsB: &dockerCompose.ServiceDeployResourcesLimits{ + CPUs: "1", + Memory: "500", + }, + expectedResult: &dockerCompose.ServiceDeployResourcesLimits{ + CPUs: "1", + Memory: "500", + }, + }, + { + serviceDeploymentResourcesLimitsA: &dockerCompose.ServiceDeployResourcesLimits{ + CPUs: "1", + }, + serviceDeploymentResourcesLimitsB: &dockerCompose.ServiceDeployResourcesLimits{ + CPUs: "2", + }, + expectedResult: &dockerCompose.ServiceDeployResourcesLimits{ + CPUs: "2", + }, + }, + { + serviceDeploymentResourcesLimitsA: &dockerCompose.ServiceDeployResourcesLimits{ + Memory: "500", + }, + serviceDeploymentResourcesLimitsB: &dockerCompose.ServiceDeployResourcesLimits{ + Memory: "1000", + }, + expectedResult: &dockerCompose.ServiceDeployResourcesLimits{ + Memory: "1000", + }, + }, + } + + for i, testCase := range testCases { + testCase.serviceDeploymentResourcesLimitsA.MergeLastWin(testCase.serviceDeploymentResourcesLimitsB) + require.True(testCase.expectedResult.Equal(testCase.serviceDeploymentResourcesLimitsA), "Failed test case %v", i) + } +} + +func TestServiceNetwork_Equal(t *testing.T) { + require := require.New(t) + + testCases := []struct { + equalableA dockerCompose.Equalable + equalableB dockerCompose.Equalable + expectedResult bool + }{ + { + equalableA: &dockerCompose.ServiceNetwork{ + Aliases: []string{}, + }, + equalableB: &dockerCompose.NetworkIPAM{}, + expectedResult: false, + }, + { + equalableA: &dockerCompose.ServiceNetwork{ + Aliases: []string{}, + }, + equalableB: nil, + expectedResult: false, + }, + { + equalableA: &dockerCompose.ServiceNetwork{ + Aliases: []string{}, + }, + equalableB: &dockerCompose.ServiceNetwork{ + Aliases: []string{}, + }, + expectedResult: true, + }, + { + equalableA: &dockerCompose.ServiceNetwork{ + Aliases: []string{"HelloWorld"}, + }, + equalableB: &dockerCompose.ServiceNetwork{ + Aliases: []string{"HelloWorld"}, + }, + expectedResult: true, + }, + { + equalableA: &dockerCompose.ServiceNetwork{ + Aliases: []string{"HelloWorld"}, + }, + equalableB: &dockerCompose.ServiceNetwork{ + Aliases: []string{"FooBar"}, + }, + expectedResult: false, + }, + { + equalableA: &dockerCompose.ServiceNetwork{ + Aliases: []string{"Hello", "World"}, + }, + equalableB: &dockerCompose.ServiceNetwork{ + Aliases: []string{"FooBar"}, + }, + expectedResult: false, + }, + } + + for i, testCase := range testCases { + require.Equal(testCase.expectedResult, testCase.equalableA.Equal(testCase.equalableB), "Failed test case %v", i) + } +} + +func TestServiceULimits_Equal(t *testing.T) { + require := require.New(t) + + testCases := []struct { + equalableA dockerCompose.Equalable + equalableB dockerCompose.Equalable + expectedResult bool + }{ + { + equalableA: &dockerCompose.ServiceULimits{}, + equalableB: &dockerCompose.NetworkIPAM{}, + expectedResult: false, + }, + { + equalableA: &dockerCompose.ServiceULimits{}, + equalableB: nil, + expectedResult: false, + }, + { + equalableA: &dockerCompose.ServiceULimits{ + NProc: 0, + NoFile: dockerCompose.NewServiceULimitsNoFile(), + }, + equalableB: &dockerCompose.ServiceULimits{ + NProc: 0, + }, + expectedResult: false, + }, + { + equalableA: &dockerCompose.ServiceULimits{ + NProc: 0, + NoFile: &dockerCompose.ServiceULimitsNoFile{ + Hard: 10, + }, + }, + equalableB: &dockerCompose.ServiceULimits{ + NProc: 0, + NoFile: &dockerCompose.ServiceULimitsNoFile{ + Soft: 10, + }, + }, + expectedResult: false, + }, + { + equalableA: &dockerCompose.ServiceULimits{ + NProc: 20, + NoFile: &dockerCompose.ServiceULimitsNoFile{ + Hard: 10, + Soft: 10, + }, + }, + equalableB: &dockerCompose.ServiceULimits{ + NProc: 20, + NoFile: &dockerCompose.ServiceULimitsNoFile{ + Hard: 10, + Soft: 10, + }, + }, + expectedResult: true, + }, + } + + for i, testCase := range testCases { + require.Equal(testCase.expectedResult, testCase.equalableA.Equal(testCase.equalableB), "Failed test case %v", i) + } +} + +func TestServiceULimitsNoFile_Equal(t *testing.T) { + require := require.New(t) + + testCases := []struct { + equalableA dockerCompose.Equalable + equalableB dockerCompose.Equalable + expectedResult bool + }{ + { + equalableA: &dockerCompose.ServiceULimitsNoFile{}, + equalableB: &dockerCompose.NetworkIPAM{}, + expectedResult: false, + }, + { + equalableA: &dockerCompose.ServiceULimitsNoFile{}, + equalableB: nil, + expectedResult: false, + }, + { + equalableA: dockerCompose.NewServiceULimitsNoFile(), + equalableB: dockerCompose.NewServiceULimitsNoFile(), + expectedResult: true, + }, + { + equalableA: &dockerCompose.ServiceULimitsNoFile{ + Hard: 10, + }, + equalableB: &dockerCompose.ServiceULimitsNoFile{ + Soft: 10, + }, + expectedResult: false, + }, + { + equalableA: &dockerCompose.ServiceULimitsNoFile{ + Hard: 10, + Soft: 10, + }, + equalableB: &dockerCompose.ServiceULimitsNoFile{ + Hard: 10, + Soft: 10, + }, + expectedResult: true, + }, + } + + for i, testCase := range testCases { + require.Equal(testCase.expectedResult, testCase.equalableA.Equal(testCase.equalableB), "Failed test case %v", i) + } +} + +func TestVolume_Equal(t *testing.T) { + require := require.New(t) + + testCases := []struct { + equalableA dockerCompose.Equalable + equalableB dockerCompose.Equalable + expectedResult bool + }{ + { + equalableA: &dockerCompose.Volume{}, + equalableB: &dockerCompose.NetworkIPAM{}, + expectedResult: false, + }, + { + equalableA: &dockerCompose.Volume{}, + equalableB: nil, + expectedResult: false, + }, + { + equalableA: dockerCompose.NewVolume(), + equalableB: dockerCompose.NewVolume(), + expectedResult: true, + }, + { + equalableA: &dockerCompose.Volume{ + External: true, + }, + equalableB: &dockerCompose.Volume{ + External: false, + }, + expectedResult: false, + }, + { + equalableA: &dockerCompose.Volume{ + External: true, + }, + equalableB: &dockerCompose.Volume{ + External: true, + }, + expectedResult: true, + }, + } + + for i, testCase := range testCases { + require.Equal(testCase.expectedResult, testCase.equalableA.Equal(testCase.equalableB), "Failed test case %v", i) + } +} diff --git a/pki/domain/dockerCompose/equalable.go b/pkg/domain/dockerCompose/equalable.go similarity index 100% rename from pki/domain/dockerCompose/equalable.go rename to pkg/domain/dockerCompose/equalable.go diff --git a/pki/domain/dockerCompose/config_test.go b/pki/domain/dockerCompose/config_test.go index 357a659..2374a29 100644 --- a/pki/domain/dockerCompose/config_test.go +++ b/pki/domain/dockerCompose/config_test.go @@ -3,7 +3,7 @@ package dockerCompose_test import ( "testing" - "git.cryptic.systems/volker.raschek/dcmerge/pki/domain/dockerCompose" + "git.cryptic.systems/volker.raschek/dcmerge/pkg/domain/dockerCompose" "github.com/stretchr/testify/require" )