2094 lines
51 KiB
Go
2094 lines
51 KiB
Go
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 TestService_MergeLastWin(t *testing.T) {
|
|
require := require.New(t)
|
|
|
|
testCases := []struct {
|
|
serviceDeploymentA *dockerCompose.Service
|
|
serviceDeploymentB *dockerCompose.Service
|
|
expectedService *dockerCompose.Service
|
|
}{
|
|
{
|
|
serviceDeploymentA: nil,
|
|
serviceDeploymentB: nil,
|
|
expectedService: nil,
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{},
|
|
serviceDeploymentB: &dockerCompose.Service{},
|
|
expectedService: &dockerCompose.Service{},
|
|
},
|
|
|
|
// CapabilitiesAdd
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
CapabilitiesAdd: []string{"NET_RAW"},
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
CapabilitiesAdd: []string{},
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
CapabilitiesAdd: []string{"NET_RAW"},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
CapabilitiesAdd: []string{},
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
CapabilitiesAdd: []string{"NET_RAW"},
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
CapabilitiesAdd: []string{"NET_RAW"},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
CapabilitiesAdd: []string{"NET_RAW"},
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
CapabilitiesAdd: []string{"NET_RAW"},
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
CapabilitiesAdd: []string{"NET_RAW"},
|
|
},
|
|
},
|
|
|
|
// CapabilitiesDrop
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
CapabilitiesDrop: []string{"NET_RAW"},
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
CapabilitiesDrop: []string{},
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
CapabilitiesDrop: []string{"NET_RAW"},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
CapabilitiesDrop: []string{},
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
CapabilitiesDrop: []string{"NET_RAW"},
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
CapabilitiesDrop: []string{"NET_RAW"},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
CapabilitiesDrop: []string{"NET_RAW"},
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
CapabilitiesDrop: []string{"NET_RAW"},
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
CapabilitiesDrop: []string{"NET_RAW"},
|
|
},
|
|
},
|
|
|
|
// Deploy
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Deploy: nil,
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Deploy: nil,
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Deploy: nil,
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Deploy: dockerCompose.NewServiceDeploy(),
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Deploy: nil,
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Deploy: dockerCompose.NewServiceDeploy(),
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Deploy: nil,
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Deploy: dockerCompose.NewServiceDeploy(),
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Deploy: dockerCompose.NewServiceDeploy(),
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Deploy: dockerCompose.NewServiceDeploy(),
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Deploy: dockerCompose.NewServiceDeploy(),
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Deploy: dockerCompose.NewServiceDeploy(),
|
|
},
|
|
},
|
|
|
|
// Environments
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Environments: nil,
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Environments: nil,
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Environments: nil,
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Environments: []string{},
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Environments: nil,
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Environments: []string{},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Environments: nil,
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Environments: []string{},
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Environments: []string{},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Environments: []string{},
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Environments: []string{},
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Environments: []string{},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Environments: []string{"PROXY_HOST=u.example.com"},
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Environments: []string{"PROXY_HOST=u.example.local"},
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Environments: []string{"PROXY_HOST=u.example.local"},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Environments: []string{"PROXY_HOST=u.example.com", "PROXY_HOST=u.example.de"},
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Environments: []string{"PROXY_HOST=u.example.local"},
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Environments: []string{"PROXY_HOST=u.example.local"},
|
|
},
|
|
},
|
|
|
|
// ExtraHosts
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
ExtraHosts: nil,
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
ExtraHosts: nil,
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
ExtraHosts: nil,
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
ExtraHosts: []string{},
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
ExtraHosts: nil,
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
ExtraHosts: []string{},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
ExtraHosts: nil,
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
ExtraHosts: []string{},
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
ExtraHosts: []string{},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
ExtraHosts: []string{},
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
ExtraHosts: []string{},
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
ExtraHosts: []string{},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
ExtraHosts: []string{"extra.host.local"},
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
ExtraHosts: []string{"extra.host.local"},
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
ExtraHosts: []string{"extra.host.local"},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
ExtraHosts: []string{"extra.host.local"},
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
ExtraHosts: []string{"extra.host.com"},
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
ExtraHosts: []string{"extra.host.com", "extra.host.local"},
|
|
},
|
|
},
|
|
|
|
// Labels
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Labels: nil,
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Labels: nil,
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Labels: nil,
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Labels: []string{},
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Labels: nil,
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Labels: []string{},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Labels: nil,
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Labels: []string{},
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Labels: []string{},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Labels: []string{},
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Labels: []string{},
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Labels: []string{},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Labels: []string{"prometheus.io/scrape=true"},
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Labels: []string{"prometheus.io/scrape=true"},
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Labels: []string{"prometheus.io/scrape=true"},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Labels: []string{"prometheus.io/scrape=true", "prometheus.io/scrape=false"},
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Labels: []string{"prometheus.io/scrape=true"},
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Labels: []string{"prometheus.io/scrape=true"},
|
|
},
|
|
},
|
|
|
|
// Networks
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Networks: nil,
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Networks: nil,
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Networks: nil,
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Networks: make(map[string]*dockerCompose.ServiceNetwork),
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Networks: nil,
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Networks: make(map[string]*dockerCompose.ServiceNetwork),
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Networks: nil,
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Networks: make(map[string]*dockerCompose.ServiceNetwork),
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Networks: make(map[string]*dockerCompose.ServiceNetwork),
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Networks: make(map[string]*dockerCompose.ServiceNetwork),
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Networks: make(map[string]*dockerCompose.ServiceNetwork),
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Networks: make(map[string]*dockerCompose.ServiceNetwork),
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Networks: map[string]*dockerCompose.ServiceNetwork{
|
|
"proxy": {Aliases: []string{"app.proxy.network"}},
|
|
},
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Networks: nil,
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Networks: map[string]*dockerCompose.ServiceNetwork{
|
|
"proxy": {Aliases: []string{"app.proxy.network"}},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Networks: map[string]*dockerCompose.ServiceNetwork{
|
|
"proxy": {Aliases: []string{"app.proxy.network"}},
|
|
},
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Networks: map[string]*dockerCompose.ServiceNetwork{
|
|
"db": {Aliases: []string{"app.db.network"}},
|
|
},
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Networks: map[string]*dockerCompose.ServiceNetwork{
|
|
"db": {Aliases: []string{"app.db.network"}},
|
|
"proxy": {Aliases: []string{"app.proxy.network"}},
|
|
},
|
|
},
|
|
},
|
|
|
|
// Ports
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Ports: nil,
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Ports: nil,
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Ports: nil,
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Ports: []string{},
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Ports: nil,
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Ports: []string{},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Ports: nil,
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Ports: []string{},
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Ports: []string{},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Ports: []string{},
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Ports: []string{},
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Ports: []string{},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Ports: []string{"80:80"},
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Ports: []string{"80:80"},
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Ports: []string{"80:80"},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Ports: []string{"80:80"},
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Ports: []string{"10080:80"},
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Ports: []string{"10080:80"},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Ports: []string{"80:80/tcp"},
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Ports: []string{"80:80"},
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Ports: []string{"80:80"},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Ports: []string{"80:80"},
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Ports: []string{"10080:80/udp"},
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Ports: []string{"10080:80/udp"},
|
|
},
|
|
},
|
|
|
|
// Secrets
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Secrets: nil,
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Secrets: nil,
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Secrets: nil,
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Secrets: []string{},
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Secrets: nil,
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Secrets: []string{},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Secrets: nil,
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Secrets: []string{},
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Secrets: []string{},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Secrets: []string{},
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Secrets: []string{},
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Secrets: []string{},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Secrets: []string{"db_pass_credentials"},
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Secrets: []string{"db_pass_credentials"},
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Secrets: []string{"db_pass_credentials"},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Secrets: []string{"db_pass_credentials"},
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Secrets: []string{"oauth2_pass_credentials"},
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Secrets: []string{"db_pass_credentials", "oauth2_pass_credentials"},
|
|
},
|
|
},
|
|
|
|
// ULimits
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
ULimits: nil,
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
ULimits: nil,
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
ULimits: nil,
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
ULimits: dockerCompose.NewServiceULimits(),
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
ULimits: nil,
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
ULimits: dockerCompose.NewServiceULimits(),
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
ULimits: nil,
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
ULimits: dockerCompose.NewServiceULimits(),
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
ULimits: dockerCompose.NewServiceULimits(),
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
ULimits: dockerCompose.NewServiceULimits(),
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
ULimits: dockerCompose.NewServiceULimits(),
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
ULimits: dockerCompose.NewServiceULimits(),
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
ULimits: &dockerCompose.ServiceULimits{
|
|
NProc: 10,
|
|
NoFile: &dockerCompose.ServiceULimitsNoFile{
|
|
Hard: 10,
|
|
Soft: 10,
|
|
},
|
|
},
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
ULimits: &dockerCompose.ServiceULimits{
|
|
NProc: 10,
|
|
NoFile: &dockerCompose.ServiceULimitsNoFile{
|
|
Hard: 10,
|
|
Soft: 10,
|
|
},
|
|
},
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
ULimits: &dockerCompose.ServiceULimits{
|
|
NProc: 10,
|
|
NoFile: &dockerCompose.ServiceULimitsNoFile{
|
|
Hard: 10,
|
|
Soft: 10,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
ULimits: &dockerCompose.ServiceULimits{
|
|
NProc: 10,
|
|
NoFile: &dockerCompose.ServiceULimitsNoFile{
|
|
Hard: 10,
|
|
Soft: 10,
|
|
},
|
|
},
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
ULimits: &dockerCompose.ServiceULimits{
|
|
NProc: 15,
|
|
NoFile: &dockerCompose.ServiceULimitsNoFile{
|
|
Hard: 25,
|
|
Soft: 20,
|
|
},
|
|
},
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
ULimits: &dockerCompose.ServiceULimits{
|
|
NProc: 15,
|
|
NoFile: &dockerCompose.ServiceULimitsNoFile{
|
|
Hard: 25,
|
|
Soft: 20,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
|
|
// Volumes
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Volumes: nil,
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Volumes: nil,
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Volumes: nil,
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Volumes: []string{},
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Volumes: nil,
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Volumes: []string{},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Volumes: nil,
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Volumes: []string{},
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Volumes: []string{},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Volumes: []string{},
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Volumes: []string{},
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Volumes: []string{},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Volumes: []string{"/etc/localtime:/etc/localtime"},
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Volumes: []string{"/etc/localtime:/etc/localtime"},
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Volumes: []string{"/etc/localtime:/etc/localtime"},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.Service{
|
|
Volumes: []string{"/etc/localtime:/etc/localtime"},
|
|
},
|
|
serviceDeploymentB: &dockerCompose.Service{
|
|
Volumes: []string{"/usr/share/zoneinfo/Europe/Berlin:/etc/localtime"},
|
|
},
|
|
expectedService: &dockerCompose.Service{
|
|
Volumes: []string{"/usr/share/zoneinfo/Europe/Berlin:/etc/localtime"},
|
|
},
|
|
},
|
|
}
|
|
|
|
for i, testCase := range testCases {
|
|
testCase.serviceDeploymentA.MergeLastWin(testCase.serviceDeploymentB)
|
|
require.True(testCase.expectedService.Equal(testCase.serviceDeploymentA), "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 TestServiceDeploy_MergeLastWin(t *testing.T) {
|
|
require := require.New(t)
|
|
|
|
testCases := []struct {
|
|
serviceDeploymentA *dockerCompose.ServiceDeploy
|
|
serviceDeploymentB *dockerCompose.ServiceDeploy
|
|
expectedServiceDeployment *dockerCompose.ServiceDeploy
|
|
}{
|
|
{
|
|
serviceDeploymentA: nil,
|
|
serviceDeploymentB: nil,
|
|
expectedServiceDeployment: nil,
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.ServiceDeploy{
|
|
Resources: nil,
|
|
},
|
|
serviceDeploymentB: &dockerCompose.ServiceDeploy{
|
|
Resources: nil,
|
|
},
|
|
expectedServiceDeployment: &dockerCompose.ServiceDeploy{
|
|
Resources: nil,
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.ServiceDeploy{
|
|
Resources: &dockerCompose.ServiceDeployResources{
|
|
Limits: nil,
|
|
},
|
|
},
|
|
serviceDeploymentB: &dockerCompose.ServiceDeploy{
|
|
Resources: nil,
|
|
},
|
|
expectedServiceDeployment: &dockerCompose.ServiceDeploy{
|
|
Resources: &dockerCompose.ServiceDeployResources{
|
|
Limits: nil,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentA: &dockerCompose.ServiceDeploy{
|
|
Resources: nil,
|
|
},
|
|
serviceDeploymentB: &dockerCompose.ServiceDeploy{
|
|
Resources: &dockerCompose.ServiceDeployResources{
|
|
Limits: nil,
|
|
},
|
|
},
|
|
expectedServiceDeployment: &dockerCompose.ServiceDeploy{
|
|
Resources: &dockerCompose.ServiceDeployResources{
|
|
Limits: nil,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for i, testCase := range testCases {
|
|
testCase.serviceDeploymentA.MergeLastWin(testCase.serviceDeploymentB)
|
|
require.True(testCase.expectedServiceDeployment.Equal(testCase.serviceDeploymentA), "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 TestServiceDeployResources_MergeLastWin(t *testing.T) {
|
|
require := require.New(t)
|
|
|
|
testCases := []struct {
|
|
serviceDeploymentResourcesA *dockerCompose.ServiceDeployResources
|
|
serviceDeploymentResourcesB *dockerCompose.ServiceDeployResources
|
|
expectedServiceDeploymentResources *dockerCompose.ServiceDeployResources
|
|
}{
|
|
{
|
|
serviceDeploymentResourcesA: nil,
|
|
serviceDeploymentResourcesB: nil,
|
|
expectedServiceDeploymentResources: nil,
|
|
},
|
|
{
|
|
serviceDeploymentResourcesA: &dockerCompose.ServiceDeployResources{
|
|
Limits: nil,
|
|
},
|
|
serviceDeploymentResourcesB: &dockerCompose.ServiceDeployResources{
|
|
Limits: &dockerCompose.ServiceDeployResourcesLimits{
|
|
CPUs: "1",
|
|
Memory: "500",
|
|
},
|
|
},
|
|
expectedServiceDeploymentResources: &dockerCompose.ServiceDeployResources{
|
|
Limits: &dockerCompose.ServiceDeployResourcesLimits{
|
|
CPUs: "1",
|
|
Memory: "500",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentResourcesA: &dockerCompose.ServiceDeployResources{
|
|
Limits: &dockerCompose.ServiceDeployResourcesLimits{
|
|
CPUs: "1",
|
|
Memory: "500",
|
|
},
|
|
},
|
|
serviceDeploymentResourcesB: &dockerCompose.ServiceDeployResources{
|
|
Limits: nil,
|
|
},
|
|
expectedServiceDeploymentResources: &dockerCompose.ServiceDeployResources{
|
|
Limits: &dockerCompose.ServiceDeployResourcesLimits{
|
|
CPUs: "1",
|
|
Memory: "500",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentResourcesA: &dockerCompose.ServiceDeployResources{
|
|
Limits: &dockerCompose.ServiceDeployResourcesLimits{
|
|
CPUs: "1",
|
|
Memory: "500",
|
|
},
|
|
},
|
|
serviceDeploymentResourcesB: &dockerCompose.ServiceDeployResources{
|
|
Limits: &dockerCompose.ServiceDeployResourcesLimits{
|
|
CPUs: "2",
|
|
Memory: "1000",
|
|
},
|
|
},
|
|
expectedServiceDeploymentResources: &dockerCompose.ServiceDeployResources{
|
|
Limits: &dockerCompose.ServiceDeployResourcesLimits{
|
|
CPUs: "2",
|
|
Memory: "1000",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentResourcesA: &dockerCompose.ServiceDeployResources{
|
|
Reservations: nil,
|
|
},
|
|
serviceDeploymentResourcesB: &dockerCompose.ServiceDeployResources{
|
|
Reservations: &dockerCompose.ServiceDeployResourcesLimits{
|
|
CPUs: "1",
|
|
Memory: "500",
|
|
},
|
|
},
|
|
expectedServiceDeploymentResources: &dockerCompose.ServiceDeployResources{
|
|
Reservations: &dockerCompose.ServiceDeployResourcesLimits{
|
|
CPUs: "1",
|
|
Memory: "500",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentResourcesA: &dockerCompose.ServiceDeployResources{
|
|
Reservations: &dockerCompose.ServiceDeployResourcesLimits{
|
|
CPUs: "1",
|
|
Memory: "500",
|
|
},
|
|
},
|
|
serviceDeploymentResourcesB: &dockerCompose.ServiceDeployResources{
|
|
Reservations: nil,
|
|
},
|
|
expectedServiceDeploymentResources: &dockerCompose.ServiceDeployResources{
|
|
Reservations: &dockerCompose.ServiceDeployResourcesLimits{
|
|
CPUs: "1",
|
|
Memory: "500",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentResourcesA: &dockerCompose.ServiceDeployResources{
|
|
Reservations: &dockerCompose.ServiceDeployResourcesLimits{
|
|
CPUs: "1",
|
|
Memory: "500",
|
|
},
|
|
},
|
|
serviceDeploymentResourcesB: &dockerCompose.ServiceDeployResources{
|
|
Reservations: &dockerCompose.ServiceDeployResourcesLimits{
|
|
CPUs: "2",
|
|
Memory: "1000",
|
|
},
|
|
},
|
|
expectedServiceDeploymentResources: &dockerCompose.ServiceDeployResources{
|
|
Reservations: &dockerCompose.ServiceDeployResourcesLimits{
|
|
CPUs: "2",
|
|
Memory: "1000",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for i, testCase := range testCases {
|
|
testCase.serviceDeploymentResourcesA.MergeLastWin(testCase.serviceDeploymentResourcesB)
|
|
require.True(testCase.expectedServiceDeploymentResources.Equal(testCase.serviceDeploymentResourcesA), "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
|
|
expectedServiceDeploymentResourcesLimits *dockerCompose.ServiceDeployResourcesLimits
|
|
}{
|
|
{
|
|
serviceDeploymentResourcesLimitsA: nil,
|
|
serviceDeploymentResourcesLimitsB: nil,
|
|
expectedServiceDeploymentResourcesLimits: nil,
|
|
},
|
|
{
|
|
serviceDeploymentResourcesLimitsA: &dockerCompose.ServiceDeployResourcesLimits{
|
|
CPUs: "1",
|
|
Memory: "500",
|
|
},
|
|
serviceDeploymentResourcesLimitsB: nil,
|
|
expectedServiceDeploymentResourcesLimits: &dockerCompose.ServiceDeployResourcesLimits{
|
|
CPUs: "1",
|
|
Memory: "500",
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentResourcesLimitsA: &dockerCompose.ServiceDeployResourcesLimits{
|
|
CPUs: "1",
|
|
Memory: "500",
|
|
},
|
|
serviceDeploymentResourcesLimitsB: &dockerCompose.ServiceDeployResourcesLimits{
|
|
CPUs: "1",
|
|
Memory: "500",
|
|
},
|
|
expectedServiceDeploymentResourcesLimits: &dockerCompose.ServiceDeployResourcesLimits{
|
|
CPUs: "1",
|
|
Memory: "500",
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentResourcesLimitsA: &dockerCompose.ServiceDeployResourcesLimits{
|
|
CPUs: "1",
|
|
},
|
|
serviceDeploymentResourcesLimitsB: &dockerCompose.ServiceDeployResourcesLimits{
|
|
CPUs: "2",
|
|
},
|
|
expectedServiceDeploymentResourcesLimits: &dockerCompose.ServiceDeployResourcesLimits{
|
|
CPUs: "2",
|
|
},
|
|
},
|
|
{
|
|
serviceDeploymentResourcesLimitsA: &dockerCompose.ServiceDeployResourcesLimits{
|
|
Memory: "500",
|
|
},
|
|
serviceDeploymentResourcesLimitsB: &dockerCompose.ServiceDeployResourcesLimits{
|
|
Memory: "1000",
|
|
},
|
|
expectedServiceDeploymentResourcesLimits: &dockerCompose.ServiceDeployResourcesLimits{
|
|
Memory: "1000",
|
|
},
|
|
},
|
|
}
|
|
|
|
for i, testCase := range testCases {
|
|
testCase.serviceDeploymentResourcesLimitsA.MergeLastWin(testCase.serviceDeploymentResourcesLimitsB)
|
|
require.True(testCase.expectedServiceDeploymentResourcesLimits.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 TestServiceNetwork_MergeLastWin(t *testing.T) {
|
|
require := require.New(t)
|
|
|
|
testCases := []struct {
|
|
ServiceNetworkA *dockerCompose.ServiceNetwork
|
|
ServiceNetworkB *dockerCompose.ServiceNetwork
|
|
expectedServiceNetwork *dockerCompose.ServiceNetwork
|
|
}{
|
|
{
|
|
ServiceNetworkA: nil,
|
|
ServiceNetworkB: nil,
|
|
expectedServiceNetwork: nil,
|
|
},
|
|
{
|
|
ServiceNetworkA: &dockerCompose.ServiceNetwork{},
|
|
ServiceNetworkB: nil,
|
|
expectedServiceNetwork: &dockerCompose.ServiceNetwork{},
|
|
},
|
|
{
|
|
ServiceNetworkA: &dockerCompose.ServiceNetwork{
|
|
Aliases: []string{"my-app.example.com"},
|
|
},
|
|
ServiceNetworkB: &dockerCompose.ServiceNetwork{
|
|
Aliases: []string{"my-app.example.com"},
|
|
},
|
|
expectedServiceNetwork: &dockerCompose.ServiceNetwork{
|
|
Aliases: []string{"my-app.example.com"},
|
|
},
|
|
},
|
|
{
|
|
ServiceNetworkA: &dockerCompose.ServiceNetwork{
|
|
Aliases: []string{"my-app.example.com"},
|
|
},
|
|
ServiceNetworkB: &dockerCompose.ServiceNetwork{
|
|
Aliases: []string{"my-app.example.local"},
|
|
},
|
|
expectedServiceNetwork: &dockerCompose.ServiceNetwork{
|
|
Aliases: []string{"my-app.example.com", "my-app.example.local"},
|
|
},
|
|
},
|
|
}
|
|
|
|
for i, testCase := range testCases {
|
|
testCase.ServiceNetworkA.MergeLastWin(testCase.ServiceNetworkB)
|
|
require.True(testCase.expectedServiceNetwork.Equal(testCase.ServiceNetworkA), "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 TestServiceULimits_MergeLastWin(t *testing.T) {
|
|
require := require.New(t)
|
|
|
|
testCases := []struct {
|
|
ServiceULimitsA *dockerCompose.ServiceULimits
|
|
ServiceULimitsB *dockerCompose.ServiceULimits
|
|
expectedServiceULimits *dockerCompose.ServiceULimits
|
|
}{
|
|
{
|
|
ServiceULimitsA: nil,
|
|
ServiceULimitsB: nil,
|
|
expectedServiceULimits: nil,
|
|
},
|
|
{
|
|
ServiceULimitsA: &dockerCompose.ServiceULimits{},
|
|
ServiceULimitsB: nil,
|
|
expectedServiceULimits: &dockerCompose.ServiceULimits{},
|
|
},
|
|
{
|
|
ServiceULimitsA: &dockerCompose.ServiceULimits{
|
|
NProc: 10,
|
|
},
|
|
ServiceULimitsB: &dockerCompose.ServiceULimits{
|
|
NProc: 10,
|
|
},
|
|
expectedServiceULimits: &dockerCompose.ServiceULimits{
|
|
NProc: 10,
|
|
},
|
|
},
|
|
{
|
|
ServiceULimitsA: &dockerCompose.ServiceULimits{
|
|
NProc: 10,
|
|
},
|
|
ServiceULimitsB: &dockerCompose.ServiceULimits{
|
|
NProc: 20,
|
|
},
|
|
expectedServiceULimits: &dockerCompose.ServiceULimits{
|
|
NProc: 20,
|
|
},
|
|
},
|
|
}
|
|
|
|
for i, testCase := range testCases {
|
|
testCase.ServiceULimitsA.MergeLastWin(testCase.ServiceULimitsB)
|
|
require.True(testCase.expectedServiceULimits.Equal(testCase.ServiceULimitsA), "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 TestServiceULimitsNoFile_MergeLastWin(t *testing.T) {
|
|
require := require.New(t)
|
|
|
|
testCases := []struct {
|
|
ServiceULimitsNoFileA *dockerCompose.ServiceULimitsNoFile
|
|
ServiceULimitsNoFileB *dockerCompose.ServiceULimitsNoFile
|
|
expectedServiceULimitsNoFile *dockerCompose.ServiceULimitsNoFile
|
|
}{
|
|
{
|
|
ServiceULimitsNoFileA: nil,
|
|
ServiceULimitsNoFileB: nil,
|
|
expectedServiceULimitsNoFile: nil,
|
|
},
|
|
{
|
|
ServiceULimitsNoFileA: &dockerCompose.ServiceULimitsNoFile{},
|
|
ServiceULimitsNoFileB: nil,
|
|
expectedServiceULimitsNoFile: &dockerCompose.ServiceULimitsNoFile{},
|
|
},
|
|
{
|
|
ServiceULimitsNoFileA: &dockerCompose.ServiceULimitsNoFile{
|
|
Hard: 10,
|
|
Soft: 10,
|
|
},
|
|
ServiceULimitsNoFileB: &dockerCompose.ServiceULimitsNoFile{
|
|
Hard: 10,
|
|
Soft: 10,
|
|
},
|
|
expectedServiceULimitsNoFile: &dockerCompose.ServiceULimitsNoFile{
|
|
Hard: 10,
|
|
Soft: 10,
|
|
},
|
|
},
|
|
{
|
|
ServiceULimitsNoFileA: &dockerCompose.ServiceULimitsNoFile{
|
|
Hard: 10,
|
|
Soft: 10,
|
|
},
|
|
ServiceULimitsNoFileB: &dockerCompose.ServiceULimitsNoFile{
|
|
Hard: 20,
|
|
Soft: 10,
|
|
},
|
|
expectedServiceULimitsNoFile: &dockerCompose.ServiceULimitsNoFile{
|
|
Hard: 20,
|
|
Soft: 10,
|
|
},
|
|
},
|
|
{
|
|
ServiceULimitsNoFileA: &dockerCompose.ServiceULimitsNoFile{
|
|
Hard: 10,
|
|
Soft: 10,
|
|
},
|
|
ServiceULimitsNoFileB: &dockerCompose.ServiceULimitsNoFile{
|
|
Hard: 10,
|
|
Soft: 20,
|
|
},
|
|
expectedServiceULimitsNoFile: &dockerCompose.ServiceULimitsNoFile{
|
|
Hard: 10,
|
|
Soft: 20,
|
|
},
|
|
},
|
|
{
|
|
ServiceULimitsNoFileA: &dockerCompose.ServiceULimitsNoFile{
|
|
Hard: 10,
|
|
Soft: 10,
|
|
},
|
|
ServiceULimitsNoFileB: &dockerCompose.ServiceULimitsNoFile{
|
|
Hard: 20,
|
|
Soft: 20,
|
|
},
|
|
expectedServiceULimitsNoFile: &dockerCompose.ServiceULimitsNoFile{
|
|
Hard: 20,
|
|
Soft: 20,
|
|
},
|
|
},
|
|
}
|
|
|
|
for i, testCase := range testCases {
|
|
testCase.ServiceULimitsNoFileA.MergeLastWin(testCase.ServiceULimitsNoFileB)
|
|
require.True(testCase.expectedServiceULimitsNoFile.Equal(testCase.ServiceULimitsNoFileA), "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)
|
|
}
|
|
}
|
|
|
|
func TestVolume_MergeLastWin(t *testing.T) {
|
|
require := require.New(t)
|
|
|
|
testCases := []struct {
|
|
volumeA *dockerCompose.Volume
|
|
volumeB *dockerCompose.Volume
|
|
expectedVolume *dockerCompose.Volume
|
|
}{
|
|
{
|
|
volumeA: nil,
|
|
volumeB: nil,
|
|
expectedVolume: nil,
|
|
},
|
|
{
|
|
volumeA: &dockerCompose.Volume{},
|
|
volumeB: nil,
|
|
expectedVolume: &dockerCompose.Volume{},
|
|
},
|
|
{
|
|
volumeA: &dockerCompose.Volume{
|
|
External: true,
|
|
},
|
|
volumeB: &dockerCompose.Volume{
|
|
External: true,
|
|
},
|
|
expectedVolume: &dockerCompose.Volume{
|
|
External: true,
|
|
},
|
|
},
|
|
{
|
|
volumeA: &dockerCompose.Volume{
|
|
External: true,
|
|
},
|
|
volumeB: &dockerCompose.Volume{
|
|
External: false,
|
|
},
|
|
expectedVolume: &dockerCompose.Volume{
|
|
External: false,
|
|
},
|
|
},
|
|
}
|
|
|
|
for i, testCase := range testCases {
|
|
testCase.volumeA.MergeLastWin(testCase.volumeB)
|
|
require.True(testCase.expectedVolume.Equal(testCase.volumeA), "Failed test case %v", i)
|
|
}
|
|
}
|