fix: config_test package

This commit is contained in:
Markus Pesch 2023-07-24 10:16:42 +02:00
parent 03428e7c61
commit e09f91feea
Signed by: volker.raschek
GPG Key ID: 852BCC170D81A982
2 changed files with 487 additions and 921 deletions

View File

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

View File

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