diff --git a/pkg/domain/dockerCompose/config_test.go b/pkg/domain/dockerCompose/config_test.go
index 2374a29..0758d01 100644
--- a/pkg/domain/dockerCompose/config_test.go
+++ b/pkg/domain/dockerCompose/config_test.go
@@ -75,6 +75,493 @@ func TestNetwork_Equal(t *testing.T) {
 	}
 }
 
+func TestNetworkIPAM_Equal(t *testing.T) {
+	require := require.New(t)
+
+	testCases := []struct {
+		equalableA     dockerCompose.Equalable
+		equalableB     dockerCompose.Equalable
+		expectedResult bool
+	}{
+		{
+			equalableA:     &dockerCompose.NetworkIPAM{},
+			equalableB:     &dockerCompose.Service{},
+			expectedResult: false,
+		},
+		{
+			equalableA:     &dockerCompose.NetworkIPAM{},
+			equalableB:     nil,
+			expectedResult: false,
+		},
+		{
+			equalableA: &dockerCompose.NetworkIPAM{
+				Configs: make([]*dockerCompose.NetworkIPAMConfig, 0),
+			},
+			equalableB:     &dockerCompose.NetworkIPAM{},
+			expectedResult: false,
+		},
+		{
+			equalableA: &dockerCompose.NetworkIPAM{
+				Configs: make([]*dockerCompose.NetworkIPAMConfig, 0),
+			},
+			equalableB: &dockerCompose.NetworkIPAM{
+				Configs: make([]*dockerCompose.NetworkIPAMConfig, 0),
+			},
+			expectedResult: true,
+		},
+	}
+
+	for i, testCase := range testCases {
+		require.Equal(testCase.expectedResult, testCase.equalableA.Equal(testCase.equalableB), "Failed test case %v", i)
+	}
+}
+
+func TestNetworkIPAMConfig_Equal(t *testing.T) {
+	require := require.New(t)
+
+	testCases := []struct {
+		equalableA     dockerCompose.Equalable
+		equalableB     dockerCompose.Equalable
+		expectedResult bool
+	}{
+		{
+			equalableA:     &dockerCompose.NetworkIPAMConfig{},
+			equalableB:     &dockerCompose.Service{},
+			expectedResult: false,
+		},
+		{
+			equalableA:     &dockerCompose.NetworkIPAMConfig{},
+			equalableB:     nil,
+			expectedResult: false,
+		},
+		{
+			equalableA: &dockerCompose.NetworkIPAMConfig{
+				Subnet: "10.12.13.14/15",
+			},
+			equalableB:     &dockerCompose.NetworkIPAMConfig{},
+			expectedResult: false,
+		},
+		{
+			equalableA: &dockerCompose.NetworkIPAMConfig{
+				Subnet: "10.12.13.14/15",
+			},
+			equalableB: &dockerCompose.NetworkIPAMConfig{
+				Subnet: "10.12.13.14/15",
+			},
+			expectedResult: true,
+		},
+	}
+
+	for i, testCase := range testCases {
+		require.Equal(testCase.expectedResult, testCase.equalableA.Equal(testCase.equalableB), "Failed test case %v", i)
+	}
+}
+
+func TestSecret_Equal(t *testing.T) {
+	require := require.New(t)
+
+	testCases := []struct {
+		equalableA     dockerCompose.Equalable
+		equalableB     dockerCompose.Equalable
+		expectedResult bool
+	}{
+		{
+			equalableA:     &dockerCompose.Secret{},
+			equalableB:     &dockerCompose.Service{},
+			expectedResult: false,
+		},
+		{
+			equalableA:     &dockerCompose.Secret{},
+			equalableB:     nil,
+			expectedResult: false,
+		},
+		{
+			equalableA: &dockerCompose.Secret{
+				File: "/var/run/docker/app/secret",
+			},
+			equalableB:     &dockerCompose.Secret{},
+			expectedResult: false,
+		},
+		{
+			equalableA: &dockerCompose.Secret{
+				File: "/var/run/docker/app/secret",
+			},
+			equalableB: &dockerCompose.Secret{
+				File: "/var/run/docker/app/secret",
+			},
+			expectedResult: true,
+		},
+	}
+
+	for i, testCase := range testCases {
+		require.Equal(testCase.expectedResult, testCase.equalableA.Equal(testCase.equalableB), "Failed test case %v", i)
+	}
+}
+
+func TestService_Equal(t *testing.T) {
+	require := require.New(t)
+
+	testCases := []struct {
+		equalableA     dockerCompose.Equalable
+		equalableB     dockerCompose.Equalable
+		expectedResult bool
+	}{
+		{
+			equalableA:     &dockerCompose.Service{},
+			equalableB:     &dockerCompose.Secret{},
+			expectedResult: false,
+		},
+		{
+			equalableA:     &dockerCompose.Service{},
+			equalableB:     nil,
+			expectedResult: false,
+		},
+		{
+			equalableA:     &dockerCompose.Service{},
+			equalableB:     &dockerCompose.Service{},
+			expectedResult: true,
+		},
+		{
+			equalableA: &dockerCompose.Service{
+				CapabilitiesAdd:  []string{},
+				CapabilitiesDrop: []string{},
+				Deploy:           nil,
+				Environments:     []string{},
+				ExtraHosts:       []string{},
+				Image:            "",
+				Labels:           []string{},
+				Networks:         map[string]*dockerCompose.ServiceNetwork{},
+				Ports:            []string{},
+				Secrets:          []string{},
+				ULimits:          nil,
+				Volumes:          []string{},
+			},
+			equalableB: &dockerCompose.Service{
+				CapabilitiesAdd:  []string{},
+				CapabilitiesDrop: []string{},
+				Deploy:           nil,
+				Environments:     []string{},
+				ExtraHosts:       []string{},
+				Image:            "",
+				Labels:           []string{},
+				Networks:         map[string]*dockerCompose.ServiceNetwork{},
+				Ports:            []string{},
+				Secrets:          []string{},
+				ULimits:          nil,
+				Volumes:          []string{},
+			},
+			expectedResult: true,
+		},
+		{
+			equalableA: &dockerCompose.Service{
+				CapabilitiesAdd: []string{"NET_ADMIN"},
+			},
+			equalableB: &dockerCompose.Service{
+				CapabilitiesAdd: []string{"NET_ADMIN"},
+			},
+			expectedResult: true,
+		},
+		{
+			equalableA: &dockerCompose.Service{
+				CapabilitiesAdd: []string{"NET_ADMIN"},
+			},
+			equalableB: &dockerCompose.Service{
+				CapabilitiesAdd: []string{},
+			},
+			expectedResult: false,
+		},
+		{
+			equalableA: &dockerCompose.Service{
+				CapabilitiesDrop: []string{"NET_ADMIN"},
+			},
+			equalableB: &dockerCompose.Service{
+				CapabilitiesDrop: []string{"NET_ADMIN"},
+			},
+			expectedResult: true,
+		},
+		{
+			equalableA: &dockerCompose.Service{
+				CapabilitiesDrop: []string{"NET_ADMIN"},
+			},
+			equalableB: &dockerCompose.Service{
+				CapabilitiesDrop: []string{},
+			},
+			expectedResult: false,
+		},
+		{
+			equalableA: &dockerCompose.Service{
+				Deploy: &dockerCompose.ServiceDeploy{},
+			},
+			equalableB: &dockerCompose.Service{
+				Deploy: nil,
+			},
+			expectedResult: false,
+		},
+		{
+			equalableA: &dockerCompose.Service{
+				Environments: []string{"PROXY_HOST=localhost.localdomain"},
+			},
+			equalableB: &dockerCompose.Service{
+				Environments: []string{"PROXY_HOST=localhost.localdomain"},
+			},
+			expectedResult: true,
+		},
+		{
+			equalableA: &dockerCompose.Service{
+				Environments: []string{"PROXY_HOST=localhost.localdomain"},
+			},
+			equalableB: &dockerCompose.Service{
+				Environments: []string{"PROXY_HOST=localhost"},
+			},
+			expectedResult: false,
+		},
+		{
+			equalableA: &dockerCompose.Service{
+				Environments: []string{"PROXY_HOST=localhost.localdomain"},
+			},
+			equalableB: &dockerCompose.Service{
+				Environments: []string{"PROXY_HOST=localdomain.localhost"},
+			},
+			expectedResult: false,
+		},
+		{
+			equalableA: &dockerCompose.Service{
+				ExtraHosts: []string{"my-app.u.orbis-healthcare.com"},
+			},
+			equalableB: &dockerCompose.Service{
+				ExtraHosts: []string{"my-app.u.orbis-healthcare.com"},
+			},
+			expectedResult: true,
+		},
+		{
+			equalableA: &dockerCompose.Service{
+				ExtraHosts: []string{"my-app.u.orbis-healthcare.com"},
+			},
+			equalableB: &dockerCompose.Service{
+				ExtraHosts: []string{},
+			},
+			expectedResult: false,
+		},
+		{
+			equalableA: &dockerCompose.Service{
+				Image: "registry.example.local/my/app:latest",
+			},
+			equalableB: &dockerCompose.Service{
+				Image: "registry.example.local/my/app:latest",
+			},
+			expectedResult: true,
+		},
+		{
+			equalableA: &dockerCompose.Service{
+				Image: "registry.example.local/my/app:latest",
+			},
+			equalableB: &dockerCompose.Service{
+				Image: "",
+			},
+			expectedResult: false,
+		},
+		{
+			equalableA: &dockerCompose.Service{
+				Labels: []string{"keyA=valueA"},
+			},
+			equalableB: &dockerCompose.Service{
+				Labels: []string{"keyA=valueA"},
+			},
+			expectedResult: true,
+		},
+		{
+			equalableA: &dockerCompose.Service{
+				Labels: []string{"keyA=valueA", "keyA=valueB"},
+			},
+			equalableB: &dockerCompose.Service{
+				Labels: []string{"keyA=valueA"},
+			},
+			expectedResult: false,
+		},
+		{
+			equalableA: &dockerCompose.Service{
+				Networks: make(map[string]*dockerCompose.ServiceNetwork),
+			},
+			equalableB: &dockerCompose.Service{
+				Networks: nil,
+			},
+			expectedResult: true,
+		},
+		{
+			equalableA: &dockerCompose.Service{
+				Networks: make(map[string]*dockerCompose.ServiceNetwork),
+			},
+			equalableB: &dockerCompose.Service{
+				Networks: make(map[string]*dockerCompose.ServiceNetwork),
+			},
+			expectedResult: true,
+		},
+		{
+			equalableA: &dockerCompose.Service{
+				Ports: []string{"80:80/tcp"},
+			},
+			equalableB: &dockerCompose.Service{
+				Ports: []string{"80:80/tcp"},
+			},
+			expectedResult: true,
+		},
+		{
+			equalableA: &dockerCompose.Service{
+				Ports: []string{"80:80/tcp"},
+			},
+			equalableB: &dockerCompose.Service{
+				Ports: []string{"80:80/udp"},
+			},
+			expectedResult: false,
+		},
+		{
+			equalableA: &dockerCompose.Service{
+				Secrets: make([]string, 0),
+			},
+			equalableB: &dockerCompose.Service{
+				Secrets: make([]string, 0),
+			},
+			expectedResult: true,
+		},
+		{
+			equalableA: &dockerCompose.Service{
+				ULimits: dockerCompose.NewServiceULimits(),
+			},
+			equalableB:     &dockerCompose.Service{},
+			expectedResult: false,
+		},
+		{
+			equalableA: &dockerCompose.Service{
+				ULimits: dockerCompose.NewServiceULimits(),
+			},
+			equalableB: &dockerCompose.Service{
+				ULimits: dockerCompose.NewServiceULimits(),
+			},
+			expectedResult: true,
+		},
+		{
+			equalableA: &dockerCompose.Service{
+				Volumes: []string{"/var/run/docker/volume/mountA"},
+			},
+			equalableB: &dockerCompose.Service{
+				Volumes: []string{"/var/run/docker/volume/mountB"},
+			},
+			expectedResult: false,
+		},
+		{
+			equalableA: &dockerCompose.Service{
+				Volumes: []string{"/var/run/docker/volume/mountA"},
+			},
+			equalableB: &dockerCompose.Service{
+				Volumes: []string{"/var/run/docker/volume/mountA"},
+			},
+			expectedResult: true,
+		},
+	}
+
+	for i, testCase := range testCases {
+		require.Equal(testCase.expectedResult, testCase.equalableA.Equal(testCase.equalableB), "Failed test case %v", i)
+	}
+}
+
+func TestSecretDeploy_Equal(t *testing.T) {
+	require := require.New(t)
+
+	testCases := []struct {
+		equalableA     dockerCompose.Equalable
+		equalableB     dockerCompose.Equalable
+		expectedResult bool
+	}{
+		{
+			equalableA:     &dockerCompose.ServiceDeploy{},
+			equalableB:     &dockerCompose.Service{},
+			expectedResult: false,
+		},
+		{
+			equalableA:     &dockerCompose.ServiceDeploy{},
+			equalableB:     nil,
+			expectedResult: false,
+		},
+		{
+			equalableA: &dockerCompose.ServiceDeploy{
+				Resources: dockerCompose.NewServiceDeployResources(),
+			},
+			equalableB:     &dockerCompose.ServiceDeploy{},
+			expectedResult: false,
+		},
+		{
+			equalableA: &dockerCompose.ServiceDeploy{
+				Resources: dockerCompose.NewServiceDeployResources(),
+			},
+			equalableB: &dockerCompose.ServiceDeploy{
+				Resources: dockerCompose.NewServiceDeployResources(),
+			},
+			expectedResult: true,
+		},
+	}
+
+	for i, testCase := range testCases {
+		require.Equal(testCase.expectedResult, testCase.equalableA.Equal(testCase.equalableB), "Failed test case %v", i)
+	}
+}
+
+func TestSecretDeployResources_Equal(t *testing.T) {
+	require := require.New(t)
+
+	testCases := []struct {
+		equalableA     dockerCompose.Equalable
+		equalableB     dockerCompose.Equalable
+		expectedResult bool
+	}{
+		{
+			equalableA:     &dockerCompose.ServiceDeployResources{},
+			equalableB:     &dockerCompose.Service{},
+			expectedResult: false,
+		},
+		{
+			equalableA:     &dockerCompose.ServiceDeployResources{},
+			equalableB:     nil,
+			expectedResult: false,
+		},
+		{
+			equalableA: &dockerCompose.ServiceDeployResources{
+				Limits: dockerCompose.NewServiceDeployResourcesLimits(),
+			},
+			equalableB:     &dockerCompose.ServiceDeployResources{},
+			expectedResult: false,
+		},
+		{
+			equalableA: &dockerCompose.ServiceDeployResources{
+				Limits: dockerCompose.NewServiceDeployResourcesLimits(),
+			},
+			equalableB: &dockerCompose.ServiceDeployResources{
+				Limits: dockerCompose.NewServiceDeployResourcesLimits(),
+			},
+			expectedResult: true,
+		},
+		{
+			equalableA: &dockerCompose.ServiceDeployResources{
+				Reservations: dockerCompose.NewServiceDeployResourcesLimits(),
+			},
+			equalableB:     &dockerCompose.ServiceDeployResources{},
+			expectedResult: false,
+		},
+		{
+			equalableA: &dockerCompose.ServiceDeployResources{
+				Reservations: dockerCompose.NewServiceDeployResourcesLimits(),
+			},
+			equalableB: &dockerCompose.ServiceDeployResources{
+				Reservations: dockerCompose.NewServiceDeployResourcesLimits(),
+			},
+			expectedResult: true,
+		},
+	}
+
+	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)
 
diff --git a/pki/domain/dockerCompose/config_test.go b/pki/domain/dockerCompose/config_test.go
deleted file mode 100644
index 0758d01..0000000
--- a/pki/domain/dockerCompose/config_test.go
+++ /dev/null
@@ -1,921 +0,0 @@
-package dockerCompose_test
-
-import (
-	"testing"
-
-	"git.cryptic.systems/volker.raschek/dcmerge/pkg/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 TestNetworkIPAM_Equal(t *testing.T) {
-	require := require.New(t)
-
-	testCases := []struct {
-		equalableA     dockerCompose.Equalable
-		equalableB     dockerCompose.Equalable
-		expectedResult bool
-	}{
-		{
-			equalableA:     &dockerCompose.NetworkIPAM{},
-			equalableB:     &dockerCompose.Service{},
-			expectedResult: false,
-		},
-		{
-			equalableA:     &dockerCompose.NetworkIPAM{},
-			equalableB:     nil,
-			expectedResult: false,
-		},
-		{
-			equalableA: &dockerCompose.NetworkIPAM{
-				Configs: make([]*dockerCompose.NetworkIPAMConfig, 0),
-			},
-			equalableB:     &dockerCompose.NetworkIPAM{},
-			expectedResult: false,
-		},
-		{
-			equalableA: &dockerCompose.NetworkIPAM{
-				Configs: make([]*dockerCompose.NetworkIPAMConfig, 0),
-			},
-			equalableB: &dockerCompose.NetworkIPAM{
-				Configs: make([]*dockerCompose.NetworkIPAMConfig, 0),
-			},
-			expectedResult: true,
-		},
-	}
-
-	for i, testCase := range testCases {
-		require.Equal(testCase.expectedResult, testCase.equalableA.Equal(testCase.equalableB), "Failed test case %v", i)
-	}
-}
-
-func TestNetworkIPAMConfig_Equal(t *testing.T) {
-	require := require.New(t)
-
-	testCases := []struct {
-		equalableA     dockerCompose.Equalable
-		equalableB     dockerCompose.Equalable
-		expectedResult bool
-	}{
-		{
-			equalableA:     &dockerCompose.NetworkIPAMConfig{},
-			equalableB:     &dockerCompose.Service{},
-			expectedResult: false,
-		},
-		{
-			equalableA:     &dockerCompose.NetworkIPAMConfig{},
-			equalableB:     nil,
-			expectedResult: false,
-		},
-		{
-			equalableA: &dockerCompose.NetworkIPAMConfig{
-				Subnet: "10.12.13.14/15",
-			},
-			equalableB:     &dockerCompose.NetworkIPAMConfig{},
-			expectedResult: false,
-		},
-		{
-			equalableA: &dockerCompose.NetworkIPAMConfig{
-				Subnet: "10.12.13.14/15",
-			},
-			equalableB: &dockerCompose.NetworkIPAMConfig{
-				Subnet: "10.12.13.14/15",
-			},
-			expectedResult: true,
-		},
-	}
-
-	for i, testCase := range testCases {
-		require.Equal(testCase.expectedResult, testCase.equalableA.Equal(testCase.equalableB), "Failed test case %v", i)
-	}
-}
-
-func TestSecret_Equal(t *testing.T) {
-	require := require.New(t)
-
-	testCases := []struct {
-		equalableA     dockerCompose.Equalable
-		equalableB     dockerCompose.Equalable
-		expectedResult bool
-	}{
-		{
-			equalableA:     &dockerCompose.Secret{},
-			equalableB:     &dockerCompose.Service{},
-			expectedResult: false,
-		},
-		{
-			equalableA:     &dockerCompose.Secret{},
-			equalableB:     nil,
-			expectedResult: false,
-		},
-		{
-			equalableA: &dockerCompose.Secret{
-				File: "/var/run/docker/app/secret",
-			},
-			equalableB:     &dockerCompose.Secret{},
-			expectedResult: false,
-		},
-		{
-			equalableA: &dockerCompose.Secret{
-				File: "/var/run/docker/app/secret",
-			},
-			equalableB: &dockerCompose.Secret{
-				File: "/var/run/docker/app/secret",
-			},
-			expectedResult: true,
-		},
-	}
-
-	for i, testCase := range testCases {
-		require.Equal(testCase.expectedResult, testCase.equalableA.Equal(testCase.equalableB), "Failed test case %v", i)
-	}
-}
-
-func TestService_Equal(t *testing.T) {
-	require := require.New(t)
-
-	testCases := []struct {
-		equalableA     dockerCompose.Equalable
-		equalableB     dockerCompose.Equalable
-		expectedResult bool
-	}{
-		{
-			equalableA:     &dockerCompose.Service{},
-			equalableB:     &dockerCompose.Secret{},
-			expectedResult: false,
-		},
-		{
-			equalableA:     &dockerCompose.Service{},
-			equalableB:     nil,
-			expectedResult: false,
-		},
-		{
-			equalableA:     &dockerCompose.Service{},
-			equalableB:     &dockerCompose.Service{},
-			expectedResult: true,
-		},
-		{
-			equalableA: &dockerCompose.Service{
-				CapabilitiesAdd:  []string{},
-				CapabilitiesDrop: []string{},
-				Deploy:           nil,
-				Environments:     []string{},
-				ExtraHosts:       []string{},
-				Image:            "",
-				Labels:           []string{},
-				Networks:         map[string]*dockerCompose.ServiceNetwork{},
-				Ports:            []string{},
-				Secrets:          []string{},
-				ULimits:          nil,
-				Volumes:          []string{},
-			},
-			equalableB: &dockerCompose.Service{
-				CapabilitiesAdd:  []string{},
-				CapabilitiesDrop: []string{},
-				Deploy:           nil,
-				Environments:     []string{},
-				ExtraHosts:       []string{},
-				Image:            "",
-				Labels:           []string{},
-				Networks:         map[string]*dockerCompose.ServiceNetwork{},
-				Ports:            []string{},
-				Secrets:          []string{},
-				ULimits:          nil,
-				Volumes:          []string{},
-			},
-			expectedResult: true,
-		},
-		{
-			equalableA: &dockerCompose.Service{
-				CapabilitiesAdd: []string{"NET_ADMIN"},
-			},
-			equalableB: &dockerCompose.Service{
-				CapabilitiesAdd: []string{"NET_ADMIN"},
-			},
-			expectedResult: true,
-		},
-		{
-			equalableA: &dockerCompose.Service{
-				CapabilitiesAdd: []string{"NET_ADMIN"},
-			},
-			equalableB: &dockerCompose.Service{
-				CapabilitiesAdd: []string{},
-			},
-			expectedResult: false,
-		},
-		{
-			equalableA: &dockerCompose.Service{
-				CapabilitiesDrop: []string{"NET_ADMIN"},
-			},
-			equalableB: &dockerCompose.Service{
-				CapabilitiesDrop: []string{"NET_ADMIN"},
-			},
-			expectedResult: true,
-		},
-		{
-			equalableA: &dockerCompose.Service{
-				CapabilitiesDrop: []string{"NET_ADMIN"},
-			},
-			equalableB: &dockerCompose.Service{
-				CapabilitiesDrop: []string{},
-			},
-			expectedResult: false,
-		},
-		{
-			equalableA: &dockerCompose.Service{
-				Deploy: &dockerCompose.ServiceDeploy{},
-			},
-			equalableB: &dockerCompose.Service{
-				Deploy: nil,
-			},
-			expectedResult: false,
-		},
-		{
-			equalableA: &dockerCompose.Service{
-				Environments: []string{"PROXY_HOST=localhost.localdomain"},
-			},
-			equalableB: &dockerCompose.Service{
-				Environments: []string{"PROXY_HOST=localhost.localdomain"},
-			},
-			expectedResult: true,
-		},
-		{
-			equalableA: &dockerCompose.Service{
-				Environments: []string{"PROXY_HOST=localhost.localdomain"},
-			},
-			equalableB: &dockerCompose.Service{
-				Environments: []string{"PROXY_HOST=localhost"},
-			},
-			expectedResult: false,
-		},
-		{
-			equalableA: &dockerCompose.Service{
-				Environments: []string{"PROXY_HOST=localhost.localdomain"},
-			},
-			equalableB: &dockerCompose.Service{
-				Environments: []string{"PROXY_HOST=localdomain.localhost"},
-			},
-			expectedResult: false,
-		},
-		{
-			equalableA: &dockerCompose.Service{
-				ExtraHosts: []string{"my-app.u.orbis-healthcare.com"},
-			},
-			equalableB: &dockerCompose.Service{
-				ExtraHosts: []string{"my-app.u.orbis-healthcare.com"},
-			},
-			expectedResult: true,
-		},
-		{
-			equalableA: &dockerCompose.Service{
-				ExtraHosts: []string{"my-app.u.orbis-healthcare.com"},
-			},
-			equalableB: &dockerCompose.Service{
-				ExtraHosts: []string{},
-			},
-			expectedResult: false,
-		},
-		{
-			equalableA: &dockerCompose.Service{
-				Image: "registry.example.local/my/app:latest",
-			},
-			equalableB: &dockerCompose.Service{
-				Image: "registry.example.local/my/app:latest",
-			},
-			expectedResult: true,
-		},
-		{
-			equalableA: &dockerCompose.Service{
-				Image: "registry.example.local/my/app:latest",
-			},
-			equalableB: &dockerCompose.Service{
-				Image: "",
-			},
-			expectedResult: false,
-		},
-		{
-			equalableA: &dockerCompose.Service{
-				Labels: []string{"keyA=valueA"},
-			},
-			equalableB: &dockerCompose.Service{
-				Labels: []string{"keyA=valueA"},
-			},
-			expectedResult: true,
-		},
-		{
-			equalableA: &dockerCompose.Service{
-				Labels: []string{"keyA=valueA", "keyA=valueB"},
-			},
-			equalableB: &dockerCompose.Service{
-				Labels: []string{"keyA=valueA"},
-			},
-			expectedResult: false,
-		},
-		{
-			equalableA: &dockerCompose.Service{
-				Networks: make(map[string]*dockerCompose.ServiceNetwork),
-			},
-			equalableB: &dockerCompose.Service{
-				Networks: nil,
-			},
-			expectedResult: true,
-		},
-		{
-			equalableA: &dockerCompose.Service{
-				Networks: make(map[string]*dockerCompose.ServiceNetwork),
-			},
-			equalableB: &dockerCompose.Service{
-				Networks: make(map[string]*dockerCompose.ServiceNetwork),
-			},
-			expectedResult: true,
-		},
-		{
-			equalableA: &dockerCompose.Service{
-				Ports: []string{"80:80/tcp"},
-			},
-			equalableB: &dockerCompose.Service{
-				Ports: []string{"80:80/tcp"},
-			},
-			expectedResult: true,
-		},
-		{
-			equalableA: &dockerCompose.Service{
-				Ports: []string{"80:80/tcp"},
-			},
-			equalableB: &dockerCompose.Service{
-				Ports: []string{"80:80/udp"},
-			},
-			expectedResult: false,
-		},
-		{
-			equalableA: &dockerCompose.Service{
-				Secrets: make([]string, 0),
-			},
-			equalableB: &dockerCompose.Service{
-				Secrets: make([]string, 0),
-			},
-			expectedResult: true,
-		},
-		{
-			equalableA: &dockerCompose.Service{
-				ULimits: dockerCompose.NewServiceULimits(),
-			},
-			equalableB:     &dockerCompose.Service{},
-			expectedResult: false,
-		},
-		{
-			equalableA: &dockerCompose.Service{
-				ULimits: dockerCompose.NewServiceULimits(),
-			},
-			equalableB: &dockerCompose.Service{
-				ULimits: dockerCompose.NewServiceULimits(),
-			},
-			expectedResult: true,
-		},
-		{
-			equalableA: &dockerCompose.Service{
-				Volumes: []string{"/var/run/docker/volume/mountA"},
-			},
-			equalableB: &dockerCompose.Service{
-				Volumes: []string{"/var/run/docker/volume/mountB"},
-			},
-			expectedResult: false,
-		},
-		{
-			equalableA: &dockerCompose.Service{
-				Volumes: []string{"/var/run/docker/volume/mountA"},
-			},
-			equalableB: &dockerCompose.Service{
-				Volumes: []string{"/var/run/docker/volume/mountA"},
-			},
-			expectedResult: true,
-		},
-	}
-
-	for i, testCase := range testCases {
-		require.Equal(testCase.expectedResult, testCase.equalableA.Equal(testCase.equalableB), "Failed test case %v", i)
-	}
-}
-
-func TestSecretDeploy_Equal(t *testing.T) {
-	require := require.New(t)
-
-	testCases := []struct {
-		equalableA     dockerCompose.Equalable
-		equalableB     dockerCompose.Equalable
-		expectedResult bool
-	}{
-		{
-			equalableA:     &dockerCompose.ServiceDeploy{},
-			equalableB:     &dockerCompose.Service{},
-			expectedResult: false,
-		},
-		{
-			equalableA:     &dockerCompose.ServiceDeploy{},
-			equalableB:     nil,
-			expectedResult: false,
-		},
-		{
-			equalableA: &dockerCompose.ServiceDeploy{
-				Resources: dockerCompose.NewServiceDeployResources(),
-			},
-			equalableB:     &dockerCompose.ServiceDeploy{},
-			expectedResult: false,
-		},
-		{
-			equalableA: &dockerCompose.ServiceDeploy{
-				Resources: dockerCompose.NewServiceDeployResources(),
-			},
-			equalableB: &dockerCompose.ServiceDeploy{
-				Resources: dockerCompose.NewServiceDeployResources(),
-			},
-			expectedResult: true,
-		},
-	}
-
-	for i, testCase := range testCases {
-		require.Equal(testCase.expectedResult, testCase.equalableA.Equal(testCase.equalableB), "Failed test case %v", i)
-	}
-}
-
-func TestSecretDeployResources_Equal(t *testing.T) {
-	require := require.New(t)
-
-	testCases := []struct {
-		equalableA     dockerCompose.Equalable
-		equalableB     dockerCompose.Equalable
-		expectedResult bool
-	}{
-		{
-			equalableA:     &dockerCompose.ServiceDeployResources{},
-			equalableB:     &dockerCompose.Service{},
-			expectedResult: false,
-		},
-		{
-			equalableA:     &dockerCompose.ServiceDeployResources{},
-			equalableB:     nil,
-			expectedResult: false,
-		},
-		{
-			equalableA: &dockerCompose.ServiceDeployResources{
-				Limits: dockerCompose.NewServiceDeployResourcesLimits(),
-			},
-			equalableB:     &dockerCompose.ServiceDeployResources{},
-			expectedResult: false,
-		},
-		{
-			equalableA: &dockerCompose.ServiceDeployResources{
-				Limits: dockerCompose.NewServiceDeployResourcesLimits(),
-			},
-			equalableB: &dockerCompose.ServiceDeployResources{
-				Limits: dockerCompose.NewServiceDeployResourcesLimits(),
-			},
-			expectedResult: true,
-		},
-		{
-			equalableA: &dockerCompose.ServiceDeployResources{
-				Reservations: dockerCompose.NewServiceDeployResourcesLimits(),
-			},
-			equalableB:     &dockerCompose.ServiceDeployResources{},
-			expectedResult: false,
-		},
-		{
-			equalableA: &dockerCompose.ServiceDeployResources{
-				Reservations: dockerCompose.NewServiceDeployResourcesLimits(),
-			},
-			equalableB: &dockerCompose.ServiceDeployResources{
-				Reservations: dockerCompose.NewServiceDeployResourcesLimits(),
-			},
-			expectedResult: true,
-		},
-	}
-
-	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)
-	}
-}