tyler.durden
/
compose
mirror of https://github.com/docker/compose.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

aci.convert: Normalize testing frameworks 

Signed-off-by: Christopher Crone <christopher.crone@docker.com>
This commit is contained in:
Christopher Crone 2020-07-31 14:24:04 +02:00 committed by Chris Crone
parent d8dfa468ab
commit 7c869cdd36
5 changed files with 108 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
aci/convert/container_test.go
View File

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

191
aci/convert/convert_test.go
View File

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

4
aci/convert/ports_test.go
View File

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

11
aci/convert/registrycredentials_test.go
View File

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

12
aci/convert/volume_test.go
View File

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