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