From 7c869cdd3669c993214584df9689eac6b675a4ef Mon Sep 17 00:00:00 2001 From: Christopher Crone Date: Fri, 31 Jul 2020 14:24:04 +0200 Subject: [PATCH] aci.convert: Normalize testing frameworks Signed-off-by: Christopher Crone --- aci/convert/container_test.go | 31 ++-- aci/convert/convert_test.go | 191 +++++++++++------------- aci/convert/ports_test.go | 4 +- aci/convert/registrycredentials_test.go | 11 +- aci/convert/volume_test.go | 12 +- 5 files changed, 108 insertions(+), 141 deletions(-) diff --git a/aci/convert/container_test.go b/aci/convert/container_test.go index 3512f14c1..947890832 100644 --- a/aci/convert/container_test.go +++ b/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") } diff --git a/aci/convert/convert_test.go b/aci/convert/convert_test.go index 8b46fd847..cbecf9809 100644 --- a/aci/convert/convert_test.go +++ b/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 +var convertCtx = store.AciContext{ + SubscriptionID: "subID", + ResourceGroup: "rg", + Location: "eu", } -func (suite *ConvertTestSuite) BeforeTest(suiteName, testName string) { - suite.ctx = 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()) + group, err := ToContainerGroup(convertCtx, project) + assert.NilError(t, err) - 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")})) + 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) 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)) +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 (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 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") } diff --git a/aci/convert/ports_test.go b/aci/convert/ports_test.go index 78af6ed6d..60ef948bf 100644 --- a/aci/convert/ports_test.go +++ b/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) }) } } diff --git a/aci/convert/registrycredentials_test.go b/aci/convert/registrycredentials_test.go index ee3eaf839..d8a112d6b 100644 --- a/aci/convert/registrycredentials_test.go +++ b/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"), diff --git a/aci/convert/volume_test.go b/aci/convert/volume_test.go index 0426172ea..6a9da4470 100644 --- a/aci/convert/volume_test.go +++ b/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") }