aci.convert: Normalize testing frameworks

Signed-off-by: Christopher Crone <[email protected]>

aci/convert/container_test.go

@@ -21,46 +21,35 @@ import (
 
 	"github.com/Azure/go-autorest/autorest/to"
 	"github.com/compose-spec/compose-go/types"
+	"gotest.tools/v3/assert"
 
 	"github.com/docker/api/containers"
-
-	. "github.com/onsi/gomega"
-	"github.com/stretchr/testify/suite"
 )
 
-type ContainerConvertTestSuite struct {
-	suite.Suite
-}
-
-func (suite *ContainerConvertTestSuite) TestConvertContainerEnvironment() {
+func TestConvertContainerEnvironment(t *testing.T) {
 	container := containers.ContainerConfig{
 		ID:          "container1",
 		Environment: []string{"key1=value1", "key2", "key3=value3"},
 	}
 	project, err := ContainerToComposeProject(container)
-	Expect(err).To(BeNil())
+	assert.NilError(t, err)
 	service1 := project.Services[0]
-	Expect(service1.Name).To(Equal(container.ID))
-	Expect(service1.Environment).To(Equal(types.MappingWithEquals{
+	assert.Equal(t, service1.Name, container.ID)
+	assert.DeepEqual(t, service1.Environment, types.MappingWithEquals{
 		"key1": to.StringPtr("value1"),
 		"key2": nil,
 		"key3": to.StringPtr("value3"),
-	}))
+	})
 }
 
-func (suite *ContainerConvertTestSuite) TestConvertRestartPolicy() {
+func TestConvertRestartPolicy(t *testing.T) {
 	container := containers.ContainerConfig{
 		ID:                     "container1",
 		RestartPolicyCondition: "none",
 	}
 	project, err := ContainerToComposeProject(container)
-	Expect(err).To(BeNil())
+	assert.NilError(t, err)
 	service1 := project.Services[0]
-	Expect(service1.Name).To(Equal(container.ID))
-	Expect(service1.Deploy.RestartPolicy.Condition).To(Equal("none"))
-}
-
-func TestContainerConvertTestSuite(t *testing.T) {
-	RegisterTestingT(t)
-	suite.Run(t, new(ContainerConvertTestSuite))
+	assert.Equal(t, service1.Name, container.ID)
+	assert.Equal(t, service1.Deploy.RestartPolicy.Condition, "none")
 }

aci/convert/convert_test.go

@@ -23,38 +23,29 @@ import (
 	"github.com/Azure/azure-sdk-for-go/profiles/latest/containerinstance/mgmt/containerinstance"
 	"github.com/Azure/go-autorest/autorest/to"
 	"github.com/compose-spec/compose-go/types"
+	"gotest.tools/v3/assert"
+	is "gotest.tools/v3/assert/cmp"
 
 	"github.com/docker/api/containers"
 	"github.com/docker/api/context/store"
-
-	. "github.com/onsi/gomega"
-	"github.com/stretchr/testify/require"
-	"github.com/stretchr/testify/suite"
 )
 
-type ConvertTestSuite struct {
-	suite.Suite
-	ctx store.AciContext
-}
-
-func (suite *ConvertTestSuite) BeforeTest(suiteName, testName string) {
-	suite.ctx = store.AciContext{
-		SubscriptionID: "subID",
-		ResourceGroup:  "rg",
-		Location:       "eu",
-	}
+var convertCtx = store.AciContext{
+	SubscriptionID: "subID",
+	ResourceGroup:  "rg",
+	Location:       "eu",
 }
 
-func (suite *ConvertTestSuite) TestProjectName() {
+func TestProjectName(t *testing.T) {
 	project := types.Project{
 		Name: "TEST",
 	}
-	containerGroup, err := ToContainerGroup(suite.ctx, project)
-	require.NoError(suite.T(), err)
-	require.Equal(suite.T(), *containerGroup.Name, "test")
+	containerGroup, err := ToContainerGroup(convertCtx, project)
+	assert.NilError(t, err)
+	assert.Equal(t, *containerGroup.Name, "test")
 }
 
-func (suite *ConvertTestSuite) TestContainerGroupToContainer() {
+func TestContainerGroupToContainer(t *testing.T) {
 	myContainerGroup := containerinstance.ContainerGroup{
 		ContainerGroupProperties: &containerinstance.ContainerGroupProperties{
 			IPAddress: &containerinstance.IPAddress{
@@ -108,11 +99,11 @@ func (suite *ConvertTestSuite) TestContainerGroupToContainer() {
 	}
 
 	container, err := ContainerGroupToContainer("myContainerID", myContainerGroup, myContainer)
-	Expect(err).To(BeNil())
-	Expect(container).To(Equal(expectedContainer))
+	assert.NilError(t, err)
+	assert.DeepEqual(t, container, expectedContainer)
 }
 
-func (suite *ConvertTestSuite) TestComposeContainerGroupToContainerWithDnsSideCarSide() {
+func TestComposeContainerGroupToContainerWithDnsSideCarSide(t *testing.T) {
 	project := types.Project{
 		Services: []types.ServiceConfig{
 			{
@@ -126,22 +117,22 @@ func (suite *ConvertTestSuite) TestComposeContainerGroupToContainerWithDnsSideCa
 		},
 	}
 
-	group, err := ToContainerGroup(suite.ctx, project)
-	Expect(err).To(BeNil())
-	Expect(len(*group.Containers)).To(Equal(3))
+	group, err := ToContainerGroup(convertCtx, project)
+	assert.NilError(t, err)
+	assert.Assert(t, is.Len(*group.Containers, 3))
 
-	Expect(*(*group.Containers)[0].Name).To(Equal("service1"))
-	Expect(*(*group.Containers)[1].Name).To(Equal("service2"))
-	Expect(*(*group.Containers)[2].Name).To(Equal(ComposeDNSSidecarName))
+	assert.Equal(t, *(*group.Containers)[0].Name, "service1")
+	assert.Equal(t, *(*group.Containers)[1].Name, "service2")
+	assert.Equal(t, *(*group.Containers)[2].Name, ComposeDNSSidecarName)
 
-	Expect(*(*group.Containers)[2].Command).To(Equal([]string{"sh", "-c", "echo 127.0.0.1 service1 >> /etc/hosts;echo 127.0.0.1 service2 >> /etc/hosts;sleep infinity"}))
+	assert.DeepEqual(t, *(*group.Containers)[2].Command, []string{"sh", "-c", "echo 127.0.0.1 service1 >> /etc/hosts;echo 127.0.0.1 service2 >> /etc/hosts;sleep infinity"})
 
-	Expect(*(*group.Containers)[0].Image).To(Equal("image1"))
-	Expect(*(*group.Containers)[1].Image).To(Equal("image2"))
-	Expect(*(*group.Containers)[2].Image).To(Equal(dnsSidecarImage))
+	assert.Equal(t, *(*group.Containers)[0].Image, "image1")
+	assert.Equal(t, *(*group.Containers)[1].Image, "image2")
+	assert.Equal(t, *(*group.Containers)[2].Image, dnsSidecarImage)
 }
 
-func (suite *ConvertTestSuite) TestComposeSingleContainerGroupToContainerNoDnsSideCarSide() {
+func TestComposeSingleContainerGroupToContainerNoDnsSideCarSide(t *testing.T) {
 	project := types.Project{
 		Services: []types.ServiceConfig{
 			{
@@ -151,15 +142,15 @@ func (suite *ConvertTestSuite) TestComposeSingleContainerGroupToContainerNoDnsSi
 		},
 	}
 
-	group, err := ToContainerGroup(suite.ctx, project)
-	Expect(err).To(BeNil())
+	group, err := ToContainerGroup(convertCtx, project)
+	assert.NilError(t, err)
 
-	Expect(len(*group.Containers)).To(Equal(1))
-	Expect(*(*group.Containers)[0].Name).To(Equal("service1"))
-	Expect(*(*group.Containers)[0].Image).To(Equal("image1"))
+	assert.Assert(t, is.Len(*group.Containers, 1))
+	assert.Equal(t, *(*group.Containers)[0].Name, "service1")
+	assert.Equal(t, *(*group.Containers)[0].Image, "image1")
 }
 
-func (suite *ConvertTestSuite) TestComposeSingleContainerGroupToContainerSpecificRestartPolicy() {
+func TestComposeSingleContainerGroupToContainerSpecificRestartPolicy(t *testing.T) {
 	project := types.Project{
 		Services: []types.ServiceConfig{
 			{
@@ -174,15 +165,15 @@ func (suite *ConvertTestSuite) TestComposeSingleContainerGroupToContainerSpecifi
 		},
 	}
 
-	group, err := ToContainerGroup(suite.ctx, project)
-	Expect(err).To(BeNil())
+	group, err := ToContainerGroup(convertCtx, project)
+	assert.NilError(t, err)
 
-	Expect(len(*group.Containers)).To(Equal(1))
-	Expect(*(*group.Containers)[0].Name).To(Equal("service1"))
-	Expect(group.RestartPolicy).To(Equal(containerinstance.OnFailure))
+	assert.Assert(t, is.Len(*group.Containers, 1))
+	assert.Equal(t, *(*group.Containers)[0].Name, "service1")
+	assert.Equal(t, group.RestartPolicy, containerinstance.OnFailure)
 }
 
-func (suite *ConvertTestSuite) TestComposeSingleContainerGroupToContainerDefaultRestartPolicy() {
+func TestComposeSingleContainerGroupToContainerDefaultRestartPolicy(t *testing.T) {
 	project := types.Project{
 		Services: []types.ServiceConfig{
 			{
@@ -192,15 +183,15 @@ func (suite *ConvertTestSuite) TestComposeSingleContainerGroupToContainerDefault
 		},
 	}
 
-	group, err := ToContainerGroup(suite.ctx, project)
-	Expect(err).To(BeNil())
+	group, err := ToContainerGroup(convertCtx, project)
+	assert.NilError(t, err)
 
-	Expect(len(*group.Containers)).To(Equal(1))
-	Expect(*(*group.Containers)[0].Name).To(Equal("service1"))
-	Expect(group.RestartPolicy).To(Equal(containerinstance.Always))
+	assert.Assert(t, is.Len(*group.Containers, 1))
+	assert.Equal(t, *(*group.Containers)[0].Name, "service1")
+	assert.Equal(t, group.RestartPolicy, containerinstance.Always)
 }
 
-func (suite *ConvertTestSuite) TestComposeContainerGroupToContainerMultiplePorts() {
+func TestComposeContainerGroupToContainerMultiplePorts(t *testing.T) {
 	project := types.Project{
 		Services: []types.ServiceConfig{
 			{
@@ -226,29 +217,27 @@ func (suite *ConvertTestSuite) TestComposeContainerGroupToContainerMultiplePorts
 		},
 	}
 
-	group, err := ToContainerGroup(suite.ctx, project)
-	Expect(err).To(BeNil())
-	Expect(len(*group.Containers)).To(Equal(3))
+	group, err := ToContainerGroup(convertCtx, project)
+	assert.NilError(t, err)
+	assert.Assert(t, is.Len(*group.Containers, 3))
 
 	container1 := (*group.Containers)[0]
-	container2 := (*group.Containers)[1]
-	Expect(*container1.Name).To(Equal("service1"))
-	Expect(*container1.Image).To(Equal("image1"))
-	portsC1 := *container1.Ports
-	Expect(*portsC1[0].Port).To(Equal(int32(80)))
+	assert.Equal(t, *container1.Name, "service1")
+	assert.Equal(t, *container1.Image, "image1")
+	assert.Equal(t, *(*container1.Ports)[0].Port, int32(80))
 
-	Expect(*container2.Name).To(Equal("service2"))
-	Expect(*container2.Image).To(Equal("image2"))
-	portsC2 := *container2.Ports
-	Expect(*portsC2[0].Port).To(Equal(int32(8080)))
+	container2 := (*group.Containers)[1]
+	assert.Equal(t, *container2.Name, "service2")
+	assert.Equal(t, *container2.Image, "image2")
+	assert.Equal(t, *(*container2.Ports)[0].Port, int32(8080))
 
 	groupPorts := *group.IPAddress.Ports
-	Expect(len(groupPorts)).To(Equal(2))
-	Expect(*groupPorts[0].Port).To(Equal(int32(80)))
-	Expect(*groupPorts[1].Port).To(Equal(int32(8080)))
+	assert.Assert(t, is.Len(groupPorts, 2))
+	assert.Equal(t, *groupPorts[0].Port, int32(80))
+	assert.Equal(t, *groupPorts[1].Port, int32(8080))
 }
 
-func (suite *ConvertTestSuite) TestComposeContainerGroupToContainerResourceLimits() {
+func TestComposeContainerGroupToContainerResourceLimits(t *testing.T) {
 	_0_1Gb := 0.1 * 1024 * 1024 * 1024
 	project := types.Project{
 		Services: []types.ServiceConfig{
@@ -267,16 +256,15 @@ func (suite *ConvertTestSuite) TestComposeContainerGroupToContainerResourceLimit
 		},
 	}
 
-	group, err := ToContainerGroup(suite.ctx, project)
-	Expect(err).To(BeNil())
+	group, err := ToContainerGroup(convertCtx, project)
+	assert.NilError(t, err)
 
-	container1 := (*group.Containers)[0]
-	limits := *container1.Resources.Limits
-	Expect(*limits.CPU).To(Equal(float64(0.1)))
-	Expect(*limits.MemoryInGB).To(Equal(float64(0.1)))
+	limits := *((*group.Containers)[0]).Resources.Limits
+	assert.Equal(t, *limits.CPU, float64(0.1))
+	assert.Equal(t, *limits.MemoryInGB, float64(0.1))
 }
 
-func (suite *ConvertTestSuite) TestComposeContainerGroupToContainerResourceLimitsDefaults() {
+func TestComposeContainerGroupToContainerResourceLimitsDefaults(t *testing.T) {
 	project := types.Project{
 		Services: []types.ServiceConfig{
 			{
@@ -294,18 +282,17 @@ func (suite *ConvertTestSuite) TestComposeContainerGroupToContainerResourceLimit
 		},
 	}
 
-	group, err := ToContainerGroup(suite.ctx, project)
-	Expect(err).To(BeNil())
+	group, err := ToContainerGroup(convertCtx, project)
+	assert.NilError(t, err)
 
-	container1 := (*group.Containers)[0]
-	limits := *container1.Resources.Limits
-	Expect(*limits.CPU).To(Equal(float64(1)))
-	Expect(*limits.MemoryInGB).To(Equal(float64(1)))
+	limits := *((*group.Containers)[0]).Resources.Limits
+	assert.Equal(t, *limits.CPU, float64(1))
+	assert.Equal(t, *limits.MemoryInGB, float64(1))
 }
 
-func (suite *ConvertTestSuite) TestComposeContainerGroupToContainerenvVar() {
+func TestComposeContainerGroupToContainerenvVar(t *testing.T) {
 	err := os.Setenv("key2", "value2")
-	Expect(err).To(BeNil())
+	assert.NilError(t, err)
 	project := types.Project{
 		Services: []types.ServiceConfig{
 			{
@@ -319,31 +306,25 @@ func (suite *ConvertTestSuite) TestComposeContainerGroupToContainerenvVar() {
 		},
 	}
 
-	group, err := ToContainerGroup(suite.ctx, project)
-	Expect(err).To(BeNil())
-
-	container1 := (*group.Containers)[0]
-	envVars := *container1.EnvironmentVariables
-	Expect(len(envVars)).To(Equal(2))
-	Expect(envVars).To(ContainElement(containerinstance.EnvironmentVariable{Name: to.StringPtr("key1"), Value: to.StringPtr("value1")}))
-	Expect(envVars).To(ContainElement(containerinstance.EnvironmentVariable{Name: to.StringPtr("key2"), Value: to.StringPtr("value2")}))
-}
+	group, err := ToContainerGroup(convertCtx, project)
+	assert.NilError(t, err)
 
-func (suite *ConvertTestSuite) TestConvertToAciRestartPolicyCondition() {
-	Expect(toAciRestartPolicy("none")).To(Equal(containerinstance.Never))
-	Expect(toAciRestartPolicy("always")).To(Equal(containerinstance.Always))
-	Expect(toAciRestartPolicy("on-failure")).To(Equal(containerinstance.OnFailure))
-	Expect(toAciRestartPolicy("on-failure:5")).To(Equal(containerinstance.Always))
+	envVars := *((*group.Containers)[0]).EnvironmentVariables
+	assert.Assert(t, is.Len(envVars, 2))
+	assert.Assert(t, is.Contains(envVars, containerinstance.EnvironmentVariable{Name: to.StringPtr("key1"), Value: to.StringPtr("value1")}))
+	assert.Assert(t, is.Contains(envVars, containerinstance.EnvironmentVariable{Name: to.StringPtr("key2"), Value: to.StringPtr("value2")}))
 }
 
-func (suite *ConvertTestSuite) TestConvertToDockerRestartPolicyCondition() {
-	Expect(toContainerRestartPolicy(containerinstance.Never)).To(Equal("none"))
-	Expect(toContainerRestartPolicy(containerinstance.Always)).To(Equal("any"))
-	Expect(toContainerRestartPolicy(containerinstance.OnFailure)).To(Equal("on-failure"))
-	Expect(toContainerRestartPolicy("")).To(Equal("any"))
+func TestConvertToAciRestartPolicyCondition(t *testing.T) {
+	assert.Equal(t, toAciRestartPolicy("none"), containerinstance.Never)
+	assert.Equal(t, toAciRestartPolicy("always"), containerinstance.Always)
+	assert.Equal(t, toAciRestartPolicy("on-failure"), containerinstance.OnFailure)
+	assert.Equal(t, toAciRestartPolicy("on-failure:5"), containerinstance.Always)
 }
 
-func TestConvertTestSuite(t *testing.T) {
-	RegisterTestingT(t)
-	suite.Run(t, new(ConvertTestSuite))
+func TestConvertToDockerRestartPolicyCondition(t *testing.T) {
+	assert.Equal(t, toContainerRestartPolicy(containerinstance.Never), "none")
+	assert.Equal(t, toContainerRestartPolicy(containerinstance.Always), "any")
+	assert.Equal(t, toContainerRestartPolicy(containerinstance.OnFailure), "on-failure")
+	assert.Equal(t, toContainerRestartPolicy(""), "any")
 }

aci/convert/ports_test.go

@@ -21,7 +21,7 @@ import (
 
 	"github.com/Azure/azure-sdk-for-go/profiles/latest/containerinstance/mgmt/containerinstance"
 	"github.com/Azure/go-autorest/autorest/to"
-	"github.com/stretchr/testify/assert"
+	"gotest.tools/v3/assert"
 
 	"github.com/docker/api/containers"
 )
@@ -119,7 +119,7 @@ func TestPortConvert(t *testing.T) {
 	for _, testCase := range testCases {
 		t.Run(testCase.name, func(t *testing.T) {
 			ports := ToPorts(testCase.ip, testCase.ports)
-			assert.Equal(t, testCase.expected, ports)
+			assert.DeepEqual(t, testCase.expected, ports)
 		})
 	}
 }

aci/convert/registrycredentials_test.go

@@ -26,7 +26,7 @@ import (
 	cliconfigtypes "github.com/docker/cli/cli/config/types"
 	"github.com/stretchr/testify/mock"
 	"gotest.tools/v3/assert"
-	"gotest.tools/v3/assert/cmp"
+	is "gotest.tools/v3/assert/cmp"
 )
 
 const getAllCredentials = "getAllRegistryCredentials"
@@ -144,7 +144,6 @@ func TestNoMoreRegistriesThanImages(t *testing.T) {
 			Password: to.StringPtr("pwd"),
 		},
 	})
-
 }
 
 func TestHubAndSeveralACRRegistries(t *testing.T) {
@@ -161,19 +160,17 @@ func TestHubAndSeveralACRRegistries(t *testing.T) {
 	creds, err := getRegistryCredentials(composeServices("mycontainerregistry1.azurecr.io/privateimg", "someuser/privateImg2", "mycontainerregistry2.azurecr.io/privateimg"), loader)
 	assert.NilError(t, err)
 
-	assert.Assert(t, cmp.Contains(creds, containerinstance.ImageRegistryCredential{
+	assert.Assert(t, is.Contains(creds, containerinstance.ImageRegistryCredential{
 		Server:   to.StringPtr("mycontainerregistry1.azurecr.io"),
 		Username: to.StringPtr(tokenUsername),
 		Password: to.StringPtr("123456"),
 	}))
-
-	assert.Assert(t, cmp.Contains(creds, containerinstance.ImageRegistryCredential{
+	assert.Assert(t, is.Contains(creds, containerinstance.ImageRegistryCredential{
 		Server:   to.StringPtr("mycontainerregistry2.azurecr.io"),
 		Username: to.StringPtr(tokenUsername),
 		Password: to.StringPtr("456789"),
 	}))
-
-	assert.Assert(t, cmp.Contains(creds, containerinstance.ImageRegistryCredential{
+	assert.Assert(t, is.Contains(creds, containerinstance.ImageRegistryCredential{
 		Server:   to.StringPtr(dockerHub),
 		Username: to.StringPtr("toto"),
 		Password: to.StringPtr("pwd"),

aci/convert/volume_test.go

@@ -20,7 +20,7 @@ import (
 	"testing"
 
 	"github.com/compose-spec/compose-go/types"
-	"gotest.tools/assert"
+	"gotest.tools/v3/assert"
 
 	"github.com/docker/api/errdefs"
 )
@@ -96,28 +96,28 @@ func TestGetRunVolumes(t *testing.T) {
 
 func TestGetRunVolumesMissingFileShare(t *testing.T) {
 	_, _, err := GetRunVolumes([]string{"myuser:mykey@"})
-	assert.Equal(t, true, errdefs.IsErrParsingFailed(err))
+	assert.Assert(t, errdefs.IsErrParsingFailed(err))
 	assert.ErrorContains(t, err, "does not include a storage file share")
 }
 
 func TestGetRunVolumesMissingUser(t *testing.T) {
 	_, _, err := GetRunVolumes([]string{":mykey@myshare"})
-	assert.Equal(t, true, errdefs.IsErrParsingFailed(err))
+	assert.Assert(t, errdefs.IsErrParsingFailed(err))
 	assert.ErrorContains(t, err, "does not include a storage username")
 }
 
 func TestGetRunVolumesMissingKey(t *testing.T) {
 	_, _, err := GetRunVolumes([]string{"userwithnokey:@myshare"})
-	assert.Equal(t, true, errdefs.IsErrParsingFailed(err))
+	assert.Assert(t, errdefs.IsErrParsingFailed(err))
 	assert.ErrorContains(t, err, "does not include a storage key")
 
 	_, _, err = GetRunVolumes([]string{"userwithnokeytoo@myshare"})
-	assert.Equal(t, true, errdefs.IsErrParsingFailed(err))
+	assert.Assert(t, errdefs.IsErrParsingFailed(err))
 	assert.ErrorContains(t, err, "does not include a storage key")
 }
 
 func TestGetRunVolumesNoShare(t *testing.T) {
 	_, _, err := GetRunVolumes([]string{"noshare"})
-	assert.Equal(t, true, errdefs.IsErrParsingFailed(err))
+	assert.Assert(t, errdefs.IsErrParsingFailed(err))
 	assert.ErrorContains(t, err, "no share specified")
 }