fix: rename package

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)
+	}
+}

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"
 )