d8dfun/virtual-kubelet
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Replace testify with gotest.tools (#553)

Browse Source 
* vendor gotest.tools

* Run gotest.tools migration tools

* Fixup tests that were improperly converted

* Remove unused testify package vendors
This commit is contained in:
Brian Goff
2019-03-28 17:08:12 -07:00
committed by GitHub
parent 561ccca561
commit 947b530f1e
20 changed files with 484 additions and 2089 deletions
Download Patch File Download Diff File Expand all files Collapse all files

112
providers/aws/fargate/container_test.go
View File

@@ -6,9 +6,9 @@ import (
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/ecs"
"gotest.tools/assert"
is "gotest.tools/assert/cmp"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
corev1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/api/resource"
)
@@ -45,21 +45,21 @@ func TestContainerDefinition(t *testing.T) {
cntrSpec := anyContainerSpec
cntr, err := newContainer(&cntrSpec)
require.NoError(t, err, "failed to create container")
assert.NilError(t, err, "failed to create container")
assert.Equal(t, cntrSpec.Name, *cntr.definition.Name, "incorrect name")
assert.Equal(t, cntrSpec.Image, *cntr.definition.Image, "incorrect image")
assert.Equal(t, cntrSpec.Command[0], *cntr.definition.EntryPoint[0], "incorrect command")
assert.Check(t, is.Equal(cntrSpec.Name, *cntr.definition.Name), "incorrect name")
assert.Check(t, is.Equal(cntrSpec.Image, *cntr.definition.Image), "incorrect image")
assert.Check(t, is.Equal(cntrSpec.Command[0], *cntr.definition.EntryPoint[0]), "incorrect command")
for i, env := range cntrSpec.Args {
assert.Equal(t, env, *cntr.definition.Command[i], "incorrect args")
assert.Check(t, is.Equal(env, *cntr.definition.Command[i]), "incorrect args")
}
assert.Equal(t, cntrSpec.WorkingDir, *cntr.definition.WorkingDirectory, "incorrect working dir")
assert.Check(t, is.Equal(cntrSpec.WorkingDir, *cntr.definition.WorkingDirectory), "incorrect working dir")
for i, env := range cntrSpec.Env {
assert.Equal(t, env.Name, *cntr.definition.Environment[i].Name, "incorrect env name")
assert.Equal(t, env.Value, *cntr.definition.Environment[i].Value, "incorrect env value")
assert.Check(t, is.Equal(env.Name, *cntr.definition.Environment[i].Name), "incorrect env name")
assert.Check(t, is.Equal(env.Value, *cntr.definition.Environment[i].Value), "incorrect env value")
}
}
@@ -69,10 +69,10 @@ func TestContainerResourceRequirementsDefaults(t *testing.T) {
cntrSpec := anyContainerSpec
cntr, err := newContainer(&cntrSpec)
require.NoError(t, err, "failed to create container")
assert.NilError(t, err, "failed to create container")
assert.Equal(t, containerDefaultCPULimit, *cntr.definition.Cpu, "incorrect CPU limit")
assert.Equal(t, containerDefaultMemoryLimit, *cntr.definition.Memory, "incorrect memory limit")
assert.Check(t, is.Equal(containerDefaultCPULimit, *cntr.definition.Cpu), "incorrect CPU limit")
assert.Check(t, is.Equal(containerDefaultMemoryLimit, *cntr.definition.Memory), "incorrect memory limit")
}
// TestContainerResourceRequirementsWithRequestsNoLimits verifies whether the container gets
@@ -87,10 +87,10 @@ func TestContainerResourceRequirementsWithRequestsNoLimits(t *testing.T) {
}
cntr, err := newContainer(&cntrSpec)
require.NoError(t, err, "failed to create container")
assert.NilError(t, err, "failed to create container")
assert.Equal(t, int64(512), *cntr.definition.Cpu, "incorrect CPU limit")
assert.Equal(t, int64(768), *cntr.definition.Memory, "incorrect memory limit")
assert.Check(t, is.Equal(int64(512), *cntr.definition.Cpu), "incorrect CPU limit")
assert.Check(t, is.Equal(int64(768), *cntr.definition.Memory), "incorrect memory limit")
}
// TestContainerResourceRequirementsWithLimitsNoRequests verifies whether the container gets
@@ -105,10 +105,10 @@ func TestContainerResourceRequirementsWithLimitsNoRequests(t *testing.T) {
}
cntr, err := newContainer(&cntrSpec)
require.NoError(t, err, "failed to create container")
assert.NilError(t, err, "failed to create container")
assert.Equal(t, int64(2048), *cntr.definition.Cpu, "incorrect CPU limit")
assert.Equal(t, int64(2048), *cntr.definition.Memory, "incorrect memory limit")
assert.Check(t, is.Equal(int64(2048), *cntr.definition.Cpu), "incorrect CPU limit")
assert.Check(t, is.Equal(int64(2048), *cntr.definition.Memory), "incorrect memory limit")
}
// TestContainerResourceRequirementsWithRequestsAndLimits verifies whether the container gets
@@ -127,10 +127,10 @@ func TestContainerResourceRequirementsWithRequestsAndLimits(t *testing.T) {
}
cntr, err := newContainer(&cntrSpec)
require.NoError(t, err, "failed to create container")
assert.NilError(t, err, "failed to create container")
assert.Equal(t, int64(2048), *cntr.definition.Cpu, "incorrect CPU limit")
assert.Equal(t, int64(2048), *cntr.definition.Memory, "incorrect memory limit")
assert.Check(t, is.Equal(int64(2048), *cntr.definition.Cpu), "incorrect CPU limit")
assert.Check(t, is.Equal(int64(2048), *cntr.definition.Memory), "incorrect memory limit")
}
// TestContainerResourceRequirements verifies whether Kubernetes container resource requirements
@@ -195,9 +195,9 @@ func TestContainerResourceRequirementsTranslations(t *testing.T) {
cntrSpec.Resources = reqs
cntr, err := newContainer(&cntrSpec)
require.NoError(t, err, "failed to create container")
assert.NilError(t, err, "failed to create container")
assert.Truef(t,
assert.Check(t,
*cntr.definition.Cpu == tc.expectedCPU && *cntr.definition.Memory == tc.expectedMemoryInMiBs,
"requested (cpu:%v memory:%v) expected (cpu:%v memory:%v) observed (cpu:%v memory:%v)",
tc.requestedCPU, tc.requestedMemory,
@@ -213,7 +213,7 @@ func TestContainerStatus(t *testing.T) {
cntrSpec := anyContainerSpec
cntr, err := newContainer(&cntrSpec)
require.NoError(t, err, "failed to create container")
assert.NilError(t, err, "failed to create container")
// Fargate container status provisioning.
state := ecs.Container{
@@ -225,51 +225,51 @@ func TestContainerStatus(t *testing.T) {
status := cntr.getStatus(&state)
assert.Equal(t, anyContainerName, status.Name, "incorrect name")
assert.NotNil(t, status.State.Waiting, "incorrect state")
assert.Equal(t, anyContainerReason, status.State.Waiting.Reason, "incorrect reason")
assert.Nil(t, status.State.Running, "incorrect state")
assert.Nil(t, status.State.Terminated, "incorrect state")
assert.False(t, status.Ready, "incorrect ready")
assert.Equal(t, anyContainerImage, status.Image, "incorrect image")
assert.Check(t, is.Equal(anyContainerName, status.Name), "incorrect name")
assert.Check(t, status.State.Waiting != nil, "incorrect state")
assert.Check(t, is.Equal(anyContainerReason, status.State.Waiting.Reason), "incorrect reason")
assert.Check(t, is.Nil(status.State.Running), "incorrect state")
assert.Check(t, is.Nil(status.State.Terminated), "incorrect state")
assert.Check(t, !status.Ready, "incorrect ready")
assert.Check(t, is.Equal(anyContainerImage, status.Image), "incorrect image")
// Fargate container status pending.
state.LastStatus = aws.String(containerStatusPending)
status = cntr.getStatus(&state)
assert.Equal(t, anyContainerName, status.Name, "incorrect name")
assert.NotNil(t, status.State.Waiting, "incorrect state")
assert.Equal(t, anyContainerReason, status.State.Waiting.Reason, "incorrect reason")
assert.Nil(t, status.State.Running, "incorrect state")
assert.Nil(t, status.State.Terminated, "incorrect state")
assert.False(t, status.Ready, "incorrect ready")
assert.Equal(t, anyContainerImage, status.Image, "incorrect image")
assert.Check(t, is.Equal(anyContainerName, status.Name), "incorrect name")
assert.Check(t, status.State.Waiting != nil, "incorrect state")
assert.Check(t, is.Equal(anyContainerReason, status.State.Waiting.Reason), "incorrect reason")
assert.Check(t, is.Nil(status.State.Running), "incorrect state")
assert.Check(t, is.Nil(status.State.Terminated), "incorrect state")
assert.Check(t, !status.Ready, "incorrect ready")
assert.Check(t, is.Equal(anyContainerImage, status.Image), "incorrect image")
// Fargate container status running.
state.LastStatus = aws.String(containerStatusRunning)
status = cntr.getStatus(&state)
assert.Equal(t, anyContainerName, status.Name, "incorrect name")
assert.Nil(t, status.State.Waiting, "incorrect state")
assert.NotNil(t, status.State.Running, "incorrect state")
assert.False(t, status.State.Running.StartedAt.IsZero(), "incorrect startedat")
assert.Nil(t, status.State.Terminated, "incorrect state")
assert.True(t, status.Ready, "incorrect ready")
assert.Equal(t, anyContainerImage, status.Image, "incorrect image")
assert.Check(t, is.Equal(anyContainerName, status.Name), "incorrect name")
assert.Check(t, is.Nil(status.State.Waiting), "incorrect state")
assert.Check(t, status.State.Running != nil, "incorrect state")
assert.Check(t, !status.State.Running.StartedAt.IsZero(), "incorrect startedat")
assert.Check(t, is.Nil(status.State.Terminated), "incorrect state")
assert.Check(t, status.Ready, "incorrect ready")
assert.Check(t, is.Equal(anyContainerImage, status.Image), "incorrect image")
// Fargate container status stopped.
state.LastStatus = aws.String(containerStatusStopped)
state.ExitCode = aws.Int64(anyContainerExitCode)
status = cntr.getStatus(&state)
assert.Equal(t, anyContainerName, status.Name, "incorrect name")
assert.Nil(t, status.State.Waiting, "incorrect state")
assert.Nil(t, status.State.Running, "incorrect state")
assert.NotNil(t, status.State.Terminated, "incorrect state")
assert.Equal(t, int32(anyContainerExitCode), status.State.Terminated.ExitCode, "incorrect exitcode")
assert.Equal(t, anyContainerReason, status.State.Terminated.Reason, "incorrect reason")
assert.False(t, status.State.Terminated.StartedAt.IsZero(), "incorrect startedat")
assert.False(t, status.State.Terminated.FinishedAt.IsZero(), "incorrect finishedat")
assert.False(t, status.Ready, "incorrect ready")
assert.Equal(t, anyContainerImage, status.Image, "incorrect image")
assert.Check(t, is.Equal(anyContainerName, status.Name), "incorrect name")
assert.Check(t, is.Nil(status.State.Waiting), "incorrect state")
assert.Check(t, is.Nil(status.State.Running), "incorrect state")
assert.Check(t, status.State.Terminated != nil, "incorrect state")
assert.Check(t, is.Equal(int32(anyContainerExitCode), status.State.Terminated.ExitCode), "incorrect exitcode")
assert.Check(t, is.Equal(anyContainerReason, status.State.Terminated.Reason), "incorrect reason")
assert.Check(t, !status.State.Terminated.StartedAt.IsZero(), "incorrect startedat")
assert.Check(t, !status.State.Terminated.FinishedAt.IsZero(), "incorrect finishedat")
assert.Check(t, !status.Ready, "incorrect ready")
assert.Check(t, is.Equal(anyContainerImage, status.Image), "incorrect image")
}

16
providers/aws/fargate/pod_test.go
View File

@@ -4,7 +4,8 @@ import (
"fmt"
"testing"
"github.com/stretchr/testify/assert"
"gotest.tools/assert"
is "gotest.tools/assert/cmp"
)
// TestTaskSizeTableInvariants verifies that the task size table is in ascending order by CPU.
@@ -13,7 +14,7 @@ func TestTaskSizeTableInvariants(t *testing.T) {
prevRow := taskSizeTable[0]
for _, row := range taskSizeTable {
assert.True(t, row.cpu >= prevRow.cpu, "Task size table must be in ascending order by CPU")
assert.Check(t, row.cpu >= prevRow.cpu, "Task size table must be in ascending order by CPU")
prevRow = row
}
}
@@ -108,7 +109,7 @@ func TestPodResourceRequirements(t *testing.T) {
err := pod.mapTaskSize()
if tc.taskCPU != 0 {
// Test case is expected to succeed.
assert.NoErrorf(t, err,
assert.Check(t, err,
"mapTaskSize failed for (cpu:%v memory:%v)",
tc.podCPU, tc.podMemory)
if err != nil {
@@ -116,16 +117,15 @@ func TestPodResourceRequirements(t *testing.T) {
}
} else {
// Test case is expected to fail.
assert.Errorf(t, err,
"mapTaskSize expected to fail but succeeded for (cpu:%v memory:%v)",
assert.Check(t, is.ErrorContains(err, ""), "mapTaskSize expected to fail but succeeded for (cpu:%v memory:%v)",
tc.podCPU, tc.podMemory)
return
}
assert.True(t, pod.taskCPU >= tc.podCPU, "pod assigned less cpu than requested")
assert.True(t, pod.taskMemory >= tc.podMemory, "pod assigned less memory than requested")
assert.Check(t, pod.taskCPU >= tc.podCPU, "pod assigned less cpu than requested")
assert.Check(t, pod.taskMemory >= tc.podMemory, "pod assigned less memory than requested")
assert.Truef(t,
assert.Check(t,
pod.taskCPU == tc.taskCPU && pod.taskMemory == tc.taskMemory,
"requested (cpu:%v memory:%v) expected (cpu:%v memory:%v) observed (cpu:%v memory:%v)\n",
tc.podCPU, tc.podMemory, tc.taskCPU, tc.taskMemory, pod.taskCPU, pod.taskMemory)

233
providers/azure/aci_test.go
View File

@@ -17,10 +17,11 @@ import (
"testing"
"github.com/google/uuid"
"github.com/stretchr/testify/assert"
azure "github.com/virtual-kubelet/azure-aci/client"
"github.com/virtual-kubelet/azure-aci/client/aci"
"github.com/virtual-kubelet/virtual-kubelet/manager"
"gotest.tools/assert"
is "gotest.tools/assert/cmp"
v1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/api/resource"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -86,16 +87,16 @@ func TestMakeRegistryCredential(t *testing.T) {
cred, err := makeRegistryCredential(server, tc.authConfig)
if tc.shouldFail {
assert.NotNil(t, err, "convertion should fail")
assert.True(t, strings.Contains(err.Error(), tc.failMessage), "failed message is not expected")
assert.Check(t, err != nil, "convertion should fail")
assert.Check(t, strings.Contains(err.Error(), tc.failMessage), "failed message is not expected")
return
}
assert.Nil(t, err, "convertion should not fail")
assert.NotNil(t, cred, "credential should not be nil")
assert.Equal(t, server, cred.Server, "server doesn't match")
assert.Equal(t, username, cred.Username, "username doesn't match")
assert.Equal(t, password, cred.Password, "password doesn't match")
assert.Check(t, err, "convertion should not fail")
assert.Check(t, cred != nil, "credential should not be nil")
assert.Check(t, is.Equal(server, cred.Server), "server doesn't match")
assert.Check(t, is.Equal(username, cred.Username), "username doesn't match")
assert.Check(t, is.Equal(password, cred.Password), "password doesn't match")
})
}
}
@@ -112,19 +113,17 @@ func TestCreatePodWithoutResourceSpec(t *testing.T) {
podNamespace := "ns-" + uuid.New().String()
aciServerMocker.OnCreate = func(subscription, resourceGroup, containerGroup string, cg *aci.ContainerGroup) (int, interface{}) {
assert.Equal(t, fakeSubscription, subscription, "Subscription doesn't match")
assert.Equal(t, fakeResourceGroup, resourceGroup, "Resource group doesn't match")
assert.NotNil(t, cg, "Container group is nil")
assert.Equal(t, podNamespace+"-"+podName, containerGroup, "Container group name is not expected")
assert.NotNil(t, cg.ContainerGroupProperties, "Container group properties should not be nil")
assert.NotNil(t, cg.ContainerGroupProperties.Containers, "Containers should not be nil")
assert.Equal(t, 1, len(cg.ContainerGroupProperties.Containers), "1 Container is expected")
assert.Equal(t, "nginx", cg.ContainerGroupProperties.Containers[0].Name, "Container nginx is expected")
assert.NotNil(t, cg.ContainerGroupProperties.Containers[0].Resources, "Container resources should not be nil")
assert.NotNil(t, cg.ContainerGroupProperties.Containers[0].Resources.Requests, "Container resource requests should not be nil")
assert.Equal(t, 1.0, cg.ContainerGroupProperties.Containers[0].Resources.Requests.CPU, "Request CPU is not expected")
assert.Equal(t, 1.5, cg.ContainerGroupProperties.Containers[0].Resources.Requests.MemoryInGB, "Request Memory is not expected")
assert.Nil(t, cg.ContainerGroupProperties.Containers[0].Resources.Limits, "Limits should be nil")
assert.Check(t, is.Equal(fakeSubscription, subscription), "Subscription doesn't match")
assert.Check(t, is.Equal(fakeResourceGroup, resourceGroup), "Resource group doesn't match")
assert.Check(t, cg != nil, "Container group is nil")
assert.Check(t, is.Equal(podNamespace+"-"+podName, containerGroup), "Container group name is not expected")
assert.Check(t, cg.ContainerGroupProperties.Containers != nil, "Containers should not be nil")
assert.Check(t, is.Equal(1, len(cg.ContainerGroupProperties.Containers)), "1 Container is expected")
assert.Check(t, is.Equal("nginx", cg.ContainerGroupProperties.Containers[0].Name), "Container nginx is expected")
assert.Check(t, cg.ContainerGroupProperties.Containers[0].Resources.Requests != nil, "Container resource requests should not be nil")
assert.Check(t, is.Equal(1.0, cg.ContainerGroupProperties.Containers[0].Resources.Requests.CPU), "Request CPU is not expected")
assert.Check(t, is.Equal(1.5, cg.ContainerGroupProperties.Containers[0].Resources.Requests.MemoryInGB), "Request Memory is not expected")
assert.Check(t, is.Nil(cg.ContainerGroupProperties.Containers[0].Resources.Limits), "Limits should be nil")
return http.StatusOK, cg
}
@@ -160,19 +159,17 @@ func TestCreatePodWithResourceRequestOnly(t *testing.T) {
podNamespace := "ns-" + uuid.New().String()
aciServerMocker.OnCreate = func(subscription, resourceGroup, containerGroup string, cg *aci.ContainerGroup) (int, interface{}) {
assert.Equal(t, fakeSubscription, subscription, "Subscription doesn't match")
assert.Equal(t, fakeResourceGroup, resourceGroup, "Resource group doesn't match")
assert.NotNil(t, cg, "Container group is nil")
assert.Equal(t, podNamespace+"-"+podName, containerGroup, "Container group name is not expected")
assert.NotNil(t, cg.ContainerGroupProperties, "Container group properties should not be nil")
assert.NotNil(t, cg.ContainerGroupProperties.Containers, "Containers should not be nil")
assert.Equal(t, 1, len(cg.ContainerGroupProperties.Containers), "1 Container is expected")
assert.Equal(t, "nginx", cg.ContainerGroupProperties.Containers[0].Name, "Container nginx is expected")
assert.NotNil(t, cg.ContainerGroupProperties.Containers[0].Resources, "Container resources should not be nil")
assert.NotNil(t, cg.ContainerGroupProperties.Containers[0].Resources.Requests, "Container resource requests should not be nil")
assert.Equal(t, 1.98, cg.ContainerGroupProperties.Containers[0].Resources.Requests.CPU, "Request CPU is not expected")
assert.Equal(t, 3.4, cg.ContainerGroupProperties.Containers[0].Resources.Requests.MemoryInGB, "Request Memory is not expected")
assert.Nil(t, cg.ContainerGroupProperties.Containers[0].Resources.Limits, "Limits should be nil")
assert.Check(t, is.Equal(fakeSubscription, subscription), "Subscription doesn't match")
assert.Check(t, is.Equal(fakeResourceGroup, resourceGroup), "Resource group doesn't match")
assert.Check(t, cg != nil, "Container group is nil")
assert.Check(t, is.Equal(podNamespace+"-"+podName, containerGroup), "Container group name is not expected")
assert.Check(t, cg.ContainerGroupProperties.Containers != nil, "Containers should not be nil")
assert.Check(t, is.Equal(1, len(cg.ContainerGroupProperties.Containers)), "1 Container is expected")
assert.Check(t, is.Equal("nginx", cg.ContainerGroupProperties.Containers[0].Name), "Container nginx is expected")
assert.Check(t, cg.ContainerGroupProperties.Containers[0].Resources.Requests != nil, "Container resource requests should not be nil")
assert.Check(t, is.Equal(1.98, cg.ContainerGroupProperties.Containers[0].Resources.Requests.CPU), "Request CPU is not expected")
assert.Check(t, is.Equal(3.4, cg.ContainerGroupProperties.Containers[0].Resources.Requests.MemoryInGB), "Request Memory is not expected")
assert.Check(t, is.Nil(cg.ContainerGroupProperties.Containers[0].Resources.Limits), "Limits should be nil")
return http.StatusOK, cg
}
@@ -214,20 +211,18 @@ func TestCreatePodWithResourceRequestAndLimit(t *testing.T) {
podNamespace := "ns-" + uuid.New().String()
aciServerMocker.OnCreate = func(subscription, resourceGroup, containerGroup string, cg *aci.ContainerGroup) (int, interface{}) {
assert.Equal(t, fakeSubscription, subscription, "Subscription doesn't match")
assert.Equal(t, fakeResourceGroup, resourceGroup, "Resource group doesn't match")
assert.NotNil(t, cg, "Container group is nil")
assert.Equal(t, podNamespace+"-"+podName, containerGroup, "Container group name is not expected")
assert.NotNil(t, cg.ContainerGroupProperties, "Container group properties should not be nil")
assert.NotNil(t, cg.ContainerGroupProperties.Containers, "Containers should not be nil")
assert.Equal(t, 1, len(cg.ContainerGroupProperties.Containers), "1 Container is expected")
assert.Equal(t, "nginx", cg.ContainerGroupProperties.Containers[0].Name, "Container nginx is expected")
assert.NotNil(t, cg.ContainerGroupProperties.Containers[0].Resources, "Container resources should not be nil")
assert.NotNil(t, cg.ContainerGroupProperties.Containers[0].Resources.Requests, "Container resource requests should not be nil")
assert.Equal(t, 1.98, cg.ContainerGroupProperties.Containers[0].Resources.Requests.CPU, "Request CPU is not expected")
assert.Equal(t, 3.4, cg.ContainerGroupProperties.Containers[0].Resources.Requests.MemoryInGB, "Request Memory is not expected")
assert.Equal(t, 3.999, cg.ContainerGroupProperties.Containers[0].Resources.Limits.CPU, "Limit CPU is not expected")
assert.Equal(t, 8.01, cg.ContainerGroupProperties.Containers[0].Resources.Limits.MemoryInGB, "Limit Memory is not expected")
assert.Check(t, is.Equal(fakeSubscription, subscription), "Subscription doesn't match")
assert.Check(t, is.Equal(fakeResourceGroup, resourceGroup), "Resource group doesn't match")
assert.Check(t, cg != nil, "Container group is nil")
assert.Check(t, is.Equal(podNamespace+"-"+podName, containerGroup), "Container group name is not expected")
assert.Check(t, cg.ContainerGroupProperties.Containers != nil, "Containers should not be nil")
assert.Check(t, is.Equal(1, len(cg.ContainerGroupProperties.Containers)), "1 Container is expected")
assert.Check(t, is.Equal("nginx", cg.ContainerGroupProperties.Containers[0].Name), "Container nginx is expected")
assert.Check(t, cg.ContainerGroupProperties.Containers[0].Resources.Requests != nil, "Container resource requests should not be nil")
assert.Check(t, is.Equal(1.98, cg.ContainerGroupProperties.Containers[0].Resources.Requests.CPU), "Request CPU is not expected")
assert.Check(t, is.Equal(3.4, cg.ContainerGroupProperties.Containers[0].Resources.Requests.MemoryInGB), "Request Memory is not expected")
assert.Check(t, is.Equal(3.999, cg.ContainerGroupProperties.Containers[0].Resources.Limits.CPU), "Limit CPU is not expected")
assert.Check(t, is.Equal(8.01, cg.ContainerGroupProperties.Containers[0].Resources.Limits.MemoryInGB), "Limit Memory is not expected")
return http.StatusOK, cg
}
@@ -270,8 +265,8 @@ func TestGetPodsWithEmptyList(t *testing.T) {
}
aciServerMocker.OnGetContainerGroups = func(subscription, resourceGroup string) (int, interface{}) {
assert.Equal(t, fakeSubscription, subscription, "Subscription doesn't match")
assert.Equal(t, fakeResourceGroup, resourceGroup, "Resource group doesn't match")
assert.Check(t, is.Equal(fakeSubscription, subscription), "Subscription doesn't match")
assert.Check(t, is.Equal(fakeResourceGroup, resourceGroup), "Resource group doesn't match")
return http.StatusOK, aci.ContainerGroupListResult{
Value: []aci.ContainerGroup{},
@@ -283,8 +278,8 @@ func TestGetPodsWithEmptyList(t *testing.T) {
t.Fatal("Failed to get pods", err)
}
assert.NotNil(t, pods, "Response pods should not be nil")
assert.Equal(t, 0, len(pods), "No pod should be returned")
assert.Check(t, pods != nil, "Response pods should not be nil")
assert.Check(t, is.Equal(0, len(pods)), "No pod should be returned")
}
// Tests get pods without requests limit.
@@ -296,8 +291,8 @@ func TestGetPodsWithoutResourceRequestsLimits(t *testing.T) {
}
aciServerMocker.OnGetContainerGroups = func(subscription, resourceGroup string) (int, interface{}) {
assert.Equal(t, fakeSubscription, subscription, "Subscription doesn't match")
assert.Equal(t, fakeResourceGroup, resourceGroup, "Resource group doesn't match")
assert.Check(t, is.Equal(fakeSubscription, subscription), "Subscription doesn't match")
assert.Check(t, is.Equal(fakeResourceGroup, resourceGroup), "Resource group doesn't match")
var cg = aci.ContainerGroup{
Name: "default-nginx",
@@ -340,26 +335,19 @@ func TestGetPodsWithoutResourceRequestsLimits(t *testing.T) {
t.Fatal("Failed to get pods", err)
}
assert.NotNil(t, pods, "Response pods should not be nil")
assert.Equal(t, 1, len(pods), "No pod should be returned")
assert.Check(t, pods != nil, "Response pods should not be nil")
assert.Check(t, is.Equal(1, len(pods)), "No pod should be returned")
pod := pods[0]
assert.NotNil(t, pod, "Response pod should not be nil")
assert.NotNil(t, pod.Spec.Containers, "Containers should not be nil")
assert.NotNil(t, pod.Spec.Containers[0].Resources, "Containers[0].Resources should not be nil")
assert.Nil(t, pod.Spec.Containers[0].Resources.Limits, "Containers[0].Resources.Limits should be nil")
assert.NotNil(t, pod.Spec.Containers[0].Resources.Requests, "Containers[0].Resources.Requests should be nil")
assert.Equal(
t,
ptrQuantity(resource.MustParse("0.99")).Value(),
pod.Spec.Containers[0].Resources.Requests.Cpu().Value(),
"Containers[0].Resources.Requests.CPU doesn't match")
assert.Equal(
t,
ptrQuantity(resource.MustParse("1.5G")).Value(),
pod.Spec.Containers[0].Resources.Requests.Memory().Value(),
"Containers[0].Resources.Requests.Memory doesn't match")
assert.Check(t, pod != nil, "Response pod should not be nil")
assert.Check(t, pod.Spec.Containers != nil, "Containers should not be nil")
assert.Check(t, is.Nil(pod.Spec.Containers[0].Resources.Limits), "Containers[0].Resources.Limits should be nil")
assert.Check(t, pod.Spec.Containers[0].Resources.Requests != nil, "Containers[0].Resources.Requests should be nil")
assert.Check(t, is.Equal(ptrQuantity(resource.MustParse("0.99")).Value(),
pod.Spec.Containers[0].Resources.Requests.Cpu().Value()), "Containers[0].Resources.Requests.CPU doesn't match")
assert.Check(t, is.Equal(ptrQuantity(resource.MustParse("1.5G")).Value(),
pod.Spec.Containers[0].Resources.Requests.Memory().Value()), "Containers[0].Resources.Requests.Memory doesn't match")
}
// Tests get pod without requests limit.
@@ -374,9 +362,9 @@ func TestGetPodWithoutResourceRequestsLimits(t *testing.T) {
podNamespace := "ns-" + uuid.New().String()
aciServerMocker.OnGetContainerGroup = func(subscription, resourceGroup, containerGroup string) (int, interface{}) {
assert.Equal(t, fakeSubscription, subscription, "Subscription doesn't match")
assert.Equal(t, fakeResourceGroup, resourceGroup, "Resource group doesn't match")
assert.Equal(t, podNamespace+"-"+podName, containerGroup, "Container group name is not expected")
assert.Check(t, is.Equal(fakeSubscription, subscription), "Subscription doesn't match")
assert.Check(t, is.Equal(fakeResourceGroup, resourceGroup), "Resource group doesn't match")
assert.Check(t, is.Equal(podNamespace+"-"+podName, containerGroup), "Container group name is not expected")
return http.StatusOK, aci.ContainerGroup{
Tags: map[string]string{
@@ -414,21 +402,14 @@ func TestGetPodWithoutResourceRequestsLimits(t *testing.T) {
t.Fatal("Failed to get pod", err)
}
assert.NotNil(t, pod, "Response pod should not be nil")
assert.NotNil(t, pod.Spec.Containers, "Containers should not be nil")
assert.NotNil(t, pod.Spec.Containers[0].Resources, "Containers[0].Resources should not be nil")
assert.Nil(t, pod.Spec.Containers[0].Resources.Limits, "Containers[0].Resources.Limits should be nil")
assert.NotNil(t, pod.Spec.Containers[0].Resources.Requests, "Containers[0].Resources.Requests should be nil")
assert.Equal(
t,
ptrQuantity(resource.MustParse("0.99")).Value(),
pod.Spec.Containers[0].Resources.Requests.Cpu().Value(),
"Containers[0].Resources.Requests.CPU doesn't match")
assert.Equal(
t,
ptrQuantity(resource.MustParse("1.5G")).Value(),
pod.Spec.Containers[0].Resources.Requests.Memory().Value(),
"Containers[0].Resources.Requests.Memory doesn't match")
assert.Check(t, pod != nil, "Response pod should not be nil")
assert.Check(t, pod.Spec.Containers != nil, "Containers should not be nil")
assert.Check(t, is.Nil(pod.Spec.Containers[0].Resources.Limits), "Containers[0].Resources.Limits should be nil")
assert.Check(t, pod.Spec.Containers[0].Resources.Requests != nil, "Containers[0].Resources.Requests should be nil")
assert.Check(t, is.Equal(ptrQuantity(resource.MustParse("0.99")).Value(),
pod.Spec.Containers[0].Resources.Requests.Cpu().Value()), "Containers[0].Resources.Requests.CPU doesn't match")
assert.Check(t, is.Equal(ptrQuantity(resource.MustParse("1.5G")).Value(),
pod.Spec.Containers[0].Resources.Requests.Memory().Value()), "Containers[0].Resources.Requests.Memory doesn't match")
}
func TestGetPodWithContainerID(t *testing.T) {
@@ -446,9 +427,9 @@ func TestGetPodWithContainerID(t *testing.T) {
cgID := fmt.Sprintf("/subscriptions/%s/resourceGroups/%s/providers/Microsoft.ContainerInstance/containerGroups/%s-%s", fakeSubscription, fakeResourceGroup, podNamespace, podName)
aciServerMocker.OnGetContainerGroup = func(subscription, resourceGroup, containerGroup string) (int, interface{}) {
assert.Equal(t, fakeSubscription, subscription, "Subscription doesn't match")
assert.Equal(t, fakeResourceGroup, resourceGroup, "Resource group doesn't match")
assert.Equal(t, podNamespace+"-"+podName, containerGroup, "Container group name is not expected")
assert.Check(t, is.Equal(fakeSubscription, subscription), "Subscription doesn't match")
assert.Check(t, is.Equal(fakeResourceGroup, resourceGroup), "Resource group doesn't match")
assert.Check(t, is.Equal(podNamespace+"-"+podName, containerGroup), "Container group name is not expected")
return http.StatusOK, aci.ContainerGroup{
ID: cgID,
@@ -487,11 +468,11 @@ func TestGetPodWithContainerID(t *testing.T) {
t.Fatal("Failed to get pod", err)
}
assert.NotNil(t, pod, "Response pod should not be nil")
assert.Equal(t, 1, len(pod.Status.ContainerStatuses), "1 container status is expected")
assert.Equal(t, containerName, pod.Status.ContainerStatuses[0].Name, "Container name in the container status doesn't match")
assert.Equal(t, containerImage, pod.Status.ContainerStatuses[0].Image, "Container image in the container status doesn't match")
assert.Equal(t, getContainerID(cgID, containerName), pod.Status.ContainerStatuses[0].ContainerID, "Container ID in the container status is not expected")
assert.Check(t, pod != nil, "Response pod should not be nil")
assert.Check(t, is.Equal(1, len(pod.Status.ContainerStatuses)), "1 container status is expected")
assert.Check(t, is.Equal(containerName, pod.Status.ContainerStatuses[0].Name), "Container name in the container status doesn't match")
assert.Check(t, is.Equal(containerImage, pod.Status.ContainerStatuses[0].Image), "Container image in the container status doesn't match")
assert.Check(t, is.Equal(getContainerID(cgID, containerName), pod.Status.ContainerStatuses[0].ContainerID), "Container ID in the container status is not expected")
}
func TestPodToACISecretEnvVar(t *testing.T) {
@@ -605,21 +586,20 @@ func TestCreatePodWithLivenessProbe(t *testing.T) {
podNamespace := "ns-" + uuid.New().String()
aciServerMocker.OnCreate = func(subscription, resourceGroup, containerGroup string, cg *aci.ContainerGroup) (int, interface{}) {
assert.Equal(t, fakeSubscription, subscription, "Subscription doesn't match")
assert.Equal(t, fakeResourceGroup, resourceGroup, "Resource group doesn't match")
assert.NotNil(t, cg, "Container group is nil")
assert.Equal(t, podNamespace+"-"+podName, containerGroup, "Container group name is not expected")
assert.NotNil(t, cg.ContainerGroupProperties, "Container group properties should not be nil")
assert.NotNil(t, cg.ContainerGroupProperties.Containers, "Containers should not be nil")
assert.Equal(t, 1, len(cg.ContainerGroupProperties.Containers), "1 Container is expected")
assert.Equal(t, "nginx", cg.ContainerGroupProperties.Containers[0].Name, "Container nginx is expected")
assert.NotNil(t, cg.Containers[0].LivenessProbe, "Liveness probe expected")
assert.Equal(t, int32(10), cg.Containers[0].LivenessProbe.InitialDelaySeconds, "Initial Probe Delay doesn't match")
assert.Equal(t, int32(5), cg.Containers[0].LivenessProbe.Period, "Probe Period doesn't match")
assert.Equal(t, int32(60), cg.Containers[0].LivenessProbe.TimeoutSeconds, "Probe Timeout doesn't match")
assert.Equal(t, int32(3), cg.Containers[0].LivenessProbe.SuccessThreshold, "Probe Success Threshold doesn't match")
assert.Equal(t, int32(5), cg.Containers[0].LivenessProbe.FailureThreshold, "Probe Failure Threshold doesn't match")
assert.NotNil(t, cg.Containers[0].LivenessProbe.HTTPGet, "Expected an HTTP Get Probe")
assert.Check(t, is.Equal(fakeSubscription, subscription), "Subscription doesn't match")
assert.Check(t, is.Equal(fakeResourceGroup, resourceGroup), "Resource group doesn't match")
assert.Check(t, cg != nil, "Container group is nil")
assert.Check(t, is.Equal(podNamespace+"-"+podName, containerGroup), "Container group name is not expected")
assert.Check(t, cg.ContainerGroupProperties.Containers != nil, "Containers should not be nil")
assert.Check(t, is.Equal(1, len(cg.ContainerGroupProperties.Containers)), "1 Container is expected")
assert.Check(t, is.Equal("nginx", cg.ContainerGroupProperties.Containers[0].Name), "Container nginx is expected")
assert.Check(t, cg.Containers[0].LivenessProbe != nil, "Liveness probe expected")
assert.Check(t, is.Equal(int32(10), cg.Containers[0].LivenessProbe.InitialDelaySeconds), "Initial Probe Delay doesn't match")
assert.Check(t, is.Equal(int32(5), cg.Containers[0].LivenessProbe.Period), "Probe Period doesn't match")
assert.Check(t, is.Equal(int32(60), cg.Containers[0].LivenessProbe.TimeoutSeconds), "Probe Timeout doesn't match")
assert.Check(t, is.Equal(int32(3), cg.Containers[0].LivenessProbe.SuccessThreshold), "Probe Success Threshold doesn't match")
assert.Check(t, is.Equal(int32(5), cg.Containers[0].LivenessProbe.FailureThreshold), "Probe Failure Threshold doesn't match")
assert.Check(t, cg.Containers[0].LivenessProbe.HTTPGet != nil, "Expected an HTTP Get Probe")
return http.StatusOK, cg
}
@@ -667,21 +647,20 @@ func TestCreatePodWithReadinessProbe(t *testing.T) {
podNamespace := "ns-" + uuid.New().String()
aciServerMocker.OnCreate = func(subscription, resourceGroup, containerGroup string, cg *aci.ContainerGroup) (int, interface{}) {
assert.Equal(t, fakeSubscription, subscription, "Subscription doesn't match")
assert.Equal(t, fakeResourceGroup, resourceGroup, "Resource group doesn't match")
assert.NotNil(t, cg, "Container group is nil")
assert.Equal(t, podNamespace+"-"+podName, containerGroup, "Container group name is not expected")
assert.NotNil(t, cg.ContainerGroupProperties, "Container group properties should not be nil")
assert.NotNil(t, cg.ContainerGroupProperties.Containers, "Containers should not be nil")
assert.Equal(t, 1, len(cg.ContainerGroupProperties.Containers), "1 Container is expected")
assert.Equal(t, "nginx", cg.ContainerGroupProperties.Containers[0].Name, "Container nginx is expected")
assert.NotNil(t, cg.Containers[0].ReadinessProbe, "Readiness probe expected")
assert.Equal(t, int32(10), cg.Containers[0].ReadinessProbe.InitialDelaySeconds, "Initial Probe Delay doesn't match")
assert.Equal(t, int32(5), cg.Containers[0].ReadinessProbe.Period, "Probe Period doesn't match")
assert.Equal(t, int32(60), cg.Containers[0].ReadinessProbe.TimeoutSeconds, "Probe Timeout doesn't match")
assert.Equal(t, int32(3), cg.Containers[0].ReadinessProbe.SuccessThreshold, "Probe Success Threshold doesn't match")
assert.Equal(t, int32(5), cg.Containers[0].ReadinessProbe.FailureThreshold, "Probe Failure Threshold doesn't match")
assert.NotNil(t, cg.Containers[0].ReadinessProbe.HTTPGet, "Expected an HTTP Get Probe")
assert.Check(t, is.Equal(fakeSubscription, subscription), "Subscription doesn't match")
assert.Check(t, is.Equal(fakeResourceGroup, resourceGroup), "Resource group doesn't match")
assert.Check(t, cg != nil, "Container group is nil")
assert.Check(t, is.Equal(podNamespace+"-"+podName, containerGroup), "Container group name is not expected")
assert.Check(t, cg.ContainerGroupProperties.Containers != nil, "Containers should not be nil")
assert.Check(t, is.Equal(1, len(cg.ContainerGroupProperties.Containers)), "1 Container is expected")
assert.Check(t, is.Equal("nginx", cg.ContainerGroupProperties.Containers[0].Name), "Container nginx is expected")
assert.Check(t, cg.Containers[0].ReadinessProbe != nil, "Readiness probe expected")
assert.Check(t, is.Equal(int32(10), cg.Containers[0].ReadinessProbe.InitialDelaySeconds), "Initial Probe Delay doesn't match")
assert.Check(t, is.Equal(int32(5), cg.Containers[0].ReadinessProbe.Period), "Probe Period doesn't match")
assert.Check(t, is.Equal(int32(60), cg.Containers[0].ReadinessProbe.TimeoutSeconds), "Probe Timeout doesn't match")
assert.Check(t, is.Equal(int32(3), cg.Containers[0].ReadinessProbe.SuccessThreshold), "Probe Success Threshold doesn't match")
assert.Check(t, is.Equal(int32(5), cg.Containers[0].ReadinessProbe.FailureThreshold), "Probe Failure Threshold doesn't match")
assert.Check(t, cg.Containers[0].ReadinessProbe.HTTPGet != nil, "Expected an HTTP Get Probe")
return http.StatusOK, cg
}

53
providers/huawei/cci_test.go
View File

@@ -6,8 +6,9 @@ import (
"os"
"testing"
"github.com/stretchr/testify/assert"
"k8s.io/api/core/v1"
"gotest.tools/assert"
is "gotest.tools/assert/cmp"
v1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/util/uuid"
)
@@ -30,8 +31,8 @@ func TestCreateProject(t *testing.T) {
}
cciServerMocker.OnCreateProject = func(ns *v1.Namespace) (int, interface{}) {
assert.NotNil(t, ns, "Project is nil")
assert.Equal(t, fakeProject, ns.Name, "pod.Annotations[\"virtual-kubelet-podname\"] is not expected")
assert.Check(t, ns != nil, "Project is nil")
assert.Check(t, is.Equal(fakeProject, ns.Name), "pod.Annotations[\"virtual-kubelet-podname\"] is not expected")
return http.StatusOK, &v1.Namespace{
TypeMeta: metav1.TypeMeta{
Kind: "Namespace",
@@ -59,12 +60,12 @@ func TestCreatePod(t *testing.T) {
podNamespace := "ns-" + string(uuid.NewUUID())
cciServerMocker.OnCreatePod = func(pod *v1.Pod) (int, interface{}) {
assert.NotNil(t, pod, "Pod is nil")
assert.NotNil(t, pod.Annotations, "pod.Annotations is expected")
assert.Equal(t, podName, pod.Annotations[podAnnotationPodNameKey], "pod.Annotations[\"virtual-kubelet-podname\"] is not expected")
assert.Equal(t, podNamespace, pod.Annotations[podAnnotationNamespaceKey], "pod.Annotations[\"virtual-kubelet-namespace\"] is not expected")
assert.Equal(t, 1, len(pod.Spec.Containers), "1 Container is expected")
assert.Equal(t, "nginx", pod.Spec.Containers[0].Name, "Container nginx is expected")
assert.Check(t, pod != nil, "Pod is nil")
assert.Check(t, pod.Annotations != nil, "pod.Annotations is expected")
assert.Check(t, is.Equal(podName, pod.Annotations[podAnnotationPodNameKey]), "pod.Annotations[\"virtual-kubelet-podname\"] is not expected")
assert.Check(t, is.Equal(podNamespace, pod.Annotations[podAnnotationNamespaceKey]), "pod.Annotations[\"virtual-kubelet-namespace\"] is not expected")
assert.Check(t, is.Equal(1, len(pod.Spec.Containers)), "1 Container is expected")
assert.Check(t, is.Equal("nginx", pod.Spec.Containers[0].Name), "Container nginx is expected")
return http.StatusOK, pod
}
@@ -127,14 +128,14 @@ func TestGetPod(t *testing.T) {
t.Fatal("Failed to get pod", err)
}
assert.NotNil(t, pod, "Response pod should not be nil")
assert.NotNil(t, pod.Spec.Containers, "Containers should not be nil")
assert.Equal(t, pod.Name, "podname", "Pod name is not expected")
assert.Equal(t, pod.Namespace, "podnamespaces", "Pod namespace is not expected")
assert.Nil(t, pod.Annotations, "Pod Annotations should be nil")
assert.Equal(t, string(pod.UID), "poduid", "Pod UID is not expected")
assert.Equal(t, pod.ClusterName, "podclustername", "Pod clustername is not expected")
assert.Equal(t, pod.Spec.NodeName, "podnodename", "Pod node name is not expected")
assert.Check(t, pod != nil, "Response pod should not be nil")
assert.Check(t, pod.Spec.Containers != nil, "Containers should not be nil")
assert.Check(t, is.Equal(pod.Name, "podname"), "Pod name is not expected")
assert.Check(t, is.Equal(pod.Namespace, "podnamespaces"), "Pod namespace is not expected")
assert.Check(t, is.Nil(pod.Annotations), "Pod Annotations should be nil")
assert.Check(t, is.Equal(string(pod.UID), "poduid"), "Pod UID is not expected")
assert.Check(t, is.Equal(pod.ClusterName, "podclustername"), "Pod clustername is not expected")
assert.Check(t, is.Equal(pod.Spec.NodeName, "podnodename"), "Pod node name is not expected")
}
// Tests get pod.
@@ -179,14 +180,14 @@ func TestGetPods(t *testing.T) {
}
pod := pods[0]
assert.NotNil(t, pod, "Response pod should not be nil")
assert.NotNil(t, pod.Spec.Containers, "Containers should not be nil")
assert.Equal(t, pod.Name, "podname", "Pod name is not expected")
assert.Equal(t, pod.Namespace, "podnamespaces", "Pod namespace is not expected")
assert.Nil(t, pod.Annotations, "Pod Annotations should be nil")
assert.Equal(t, string(pod.UID), "poduid", "Pod UID is not expected")
assert.Equal(t, pod.ClusterName, "podclustername", "Pod clustername is not expected")
assert.Equal(t, pod.Spec.NodeName, "podnodename", "Pod node name is not expected")
assert.Check(t, pod != nil, "Response pod should not be nil")
assert.Check(t, pod.Spec.Containers != nil, "Containers should not be nil")
assert.Check(t, is.Equal(pod.Name, "podname"), "Pod name is not expected")
assert.Check(t, is.Equal(pod.Namespace, "podnamespaces"), "Pod namespace is not expected")
assert.Check(t, is.Nil(pod.Annotations), "Pod Annotations should be nil")
assert.Check(t, is.Equal(string(pod.UID), "poduid"), "Pod UID is not expected")
assert.Check(t, is.Equal(pod.ClusterName, "podclustername"), "Pod clustername is not expected")
assert.Check(t, is.Equal(pod.Spec.NodeName, "podnodename"), "Pod node name is not expected")
}
func prepareMocks() (*CCIMock, *CCIProvider, error) {

13
providers/nomad/nomad_test.go
View File

@@ -9,7 +9,8 @@ import (
"github.com/google/uuid"
nomad "github.com/hashicorp/nomad/api"
"github.com/hashicorp/nomad/testutil"
"github.com/stretchr/testify/assert"
"gotest.tools/assert"
is "gotest.tools/assert/cmp"
v1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/util/intstr"
@@ -77,10 +78,10 @@ func TestCreateGetDeletePod(t *testing.T) {
// Get pod tests
// Validate pod spec
assert.NotNil(t, pod, "pod cannot be nil")
assert.NotNil(t, pod.Spec.Containers, "containers cannot be nil")
assert.Nil(t, pod.Annotations, "pod annotations should be nil")
assert.Equal(t, pod.Name, fmt.Sprintf("%s-%s", jobNamePrefix, podName), "pod name should be equal")
assert.Check(t, pod != nil, "pod cannot be nil")
assert.Check(t, pod.Spec.Containers != nil, "containers cannot be nil")
assert.Check(t, is.Nil(pod.Annotations), "pod annotations should be nil")
assert.Check(t, is.Equal(pod.Name, fmt.Sprintf("%s-%s", jobNamePrefix, podName)), "pod name should be equal")
// Get pods
pods, err := provider.GetPods(context.Background())
@@ -89,7 +90,7 @@ func TestCreateGetDeletePod(t *testing.T) {
}
// TODO: finish adding a few more assertions
assert.Len(t, pods, 1, "number of pods should be 1")
assert.Check(t, is.Len(pods, 1), "number of pods should be 1")
// Delete pod
err = provider.DeletePod(context.Background(), pod)

52
providers/vic/cache/pod_cache_test.go vendored
View File

@@ -4,15 +4,16 @@ import (
"context"
"testing"
"github.com/stretchr/testify/assert"
"github.com/virtual-kubelet/virtual-kubelet/providers/vic/pod"
"k8s.io/api/core/v1"
"gotest.tools/assert"
is "gotest.tools/assert/cmp"
v1 "k8s.io/api/core/v1"
"github.com/vmware/vic/pkg/trace"
)
var (
testpod *v1.Pod
testpod *v1.Pod
)
func init() {
@@ -21,11 +22,11 @@ func init() {
func setup(t *testing.T, op trace.Operation) PodCache {
c := NewVicPodCache()
assert.NotNil(t, c, "NewPod did not return a valid cache")
assert.Check(t, c != nil, "NewPod did not return a valid cache")
//populate with dummy data
vp := pod.VicPod{
ID: "123",
ID: "123",
Pod: testpod,
}
c.Add(op, "namespace1", "testpod1a", &vp)
@@ -40,10 +41,10 @@ func TestRehydrate(t *testing.T) {
op := trace.NewOperation(context.Background(), "")
c := NewVicPodCache()
assert.NotNil(t, c, "NewPod did not return a valid cache")
assert.Check(t, c != nil, "NewPod did not return a valid cache")
err := c.Rehydrate(op)
assert.Nil(t, err, "PodCache.Rehydrate failed with error: %s", err)
assert.Check(t, err, "PodCache.Rehydrate failed with error: %s", err)
}
func TestAdd(t *testing.T) {
@@ -51,26 +52,26 @@ func TestAdd(t *testing.T) {
op := trace.NewOperation(context.Background(), "")
c := NewVicPodCache()
assert.NotNil(t, c, "NewPod did not return a valid cache")
assert.Check(t, c != nil, "NewPod did not return a valid cache")
//populate with dummy data
vp := pod.VicPod{
ID: "123",
ID: "123",
Pod: testpod,
}
// Positive cases
err = c.Add(op, "namespace1", "testpod1a", &vp)
assert.Nil(t, err, "PodCache.Add failed with error: %s", err)
assert.Check(t, err, "PodCache.Add failed with error: %s", err)
// Negative cases
err = c.Add(op, "namespace1", "", &vp)
assert.NotNil(t, err, "PodCache.Add expected error for empty name")
assert.Equal(t, err, PodCachePodNameError)
assert.Check(t, err != nil, "PodCache.Add expected error for empty name")
assert.Check(t, is.DeepEqual(err, PodCachePodNameError))
err = c.Add(op, "namespace1", "test2", nil)
assert.NotNil(t, err, "PodCache.Add expected error for nil pod")
assert.Equal(t, err, PodCacheNilPodError)
assert.Check(t, err != nil, "PodCache.Add expected error for nil pod")
assert.Check(t, is.DeepEqual(err, PodCacheNilPodError))
}
func TestGet(t *testing.T) {
@@ -82,17 +83,17 @@ func TestGet(t *testing.T) {
// Positive cases
vpod, err = c.Get(op, "namespace1", "testpod1a")
assert.Nil(t, err, "PodCache.Get failed with error: %s", err)
assert.NotNil(t, vpod, "PodCache.Get expected to return non-nil pod but received nil")
assert.Check(t, err, "PodCache.Get failed with error: %s", err)
assert.Check(t, vpod != nil, "PodCache.Get expected to return non-nil pod but received nil")
vpod, err = c.Get(op, "namespace2", "testpod2a")
assert.Nil(t, err, "PodCache.Get failed with error: %s", err)
assert.NotNil(t, vpod, "PodCache.Get expected to return non-nil pod but received nil")
assert.Check(t, err, "PodCache.Get failed with error: %s", err)
assert.Check(t, vpod != nil, "PodCache.Get expected to return non-nil pod but received nil")
// Negative cases
vpod, err = c.Get(op, "namespace1", "")
assert.Equal(t, err, PodCachePodNameError)
assert.Nil(t, vpod, "PodCache.Get expected to return nil pod but received non-nil")
assert.Check(t, is.DeepEqual(err, PodCachePodNameError))
assert.Check(t, is.Nil(vpod), "PodCache.Get expected to return nil pod but received non-nil")
//TODO: uncomment out once namespace support added to cache
//vpod, err = c.Get(op, "namespace1", "testpod2a")
@@ -108,8 +109,8 @@ func TestGetAll(t *testing.T) {
c := setup(t, op)
vps := c.GetAll(op)
assert.NotNil(t, vps, "PodCache.GetAll returned nil slice")
assert.Len(t, vps, 4, "PodCache.Get did not return all pod definitions. Returned %d pods.", len(vps))
assert.Check(t, vps != nil, "PodCache.GetAll returned nil slice")
assert.Check(t, is.Len(vps, 4), "PodCache.Get did not return all pod definitions. Returned %d pods.", len(vps))
}
func TestDelete(t *testing.T) {
@@ -120,13 +121,13 @@ func TestDelete(t *testing.T) {
// Positive cases
err = c.Delete(op, "namespace1", "testpod1a")
assert.Nil(t, err, "PodCache.Delete failed with error: %s", err)
assert.Check(t, err, "PodCache.Delete failed with error: %s", err)
vps := c.GetAll(op)
assert.Len(t, vps, 3, "PodCache.Delete did not delete pod.")
assert.Check(t, is.Len(vps, 3), "PodCache.Delete did not delete pod.")
// Negative cases
err = c.Delete(op, "namespace2", "")
assert.Equal(t, err, PodCachePodNameError)
assert.Check(t, is.DeepEqual(err, PodCachePodNameError))
//TODO: uncomment the tests below once namespace support added to cache
//vps = c.GetAll(op)
@@ -136,4 +137,3 @@ func TestDelete(t *testing.T) {
//vps = c.GetAll(op)
//assert.Len(t, vps, currCount, "PodCache.Delete ignored namespace")
}

93
providers/vic/operations/pod_creator_test.go
View File

@@ -4,9 +4,10 @@ import (
"fmt"
"testing"
"github.com/stretchr/testify/assert"
"github.com/vmware/vic/lib/apiservers/portlayer/client"
"github.com/vmware/vic/lib/metadata"
"gotest.tools/assert"
is "gotest.tools/assert/cmp"
)
func init() {
@@ -24,24 +25,24 @@ func TestNewPodCreator(t *testing.T) {
// Positive cases
c, err = NewPodCreator(client, store, proxy, cache, persona, portlayer)
assert.NotNil(t, c, "Expected not-nil creating a pod creator but received nil")
assert.Check(t, c != nil, "Expected not-nil creating a pod creator but received nil")
// Negative cases
c, err = NewPodCreator(nil, store, proxy, cache, persona, portlayer)
assert.Nil(t, c, "Expected nil")
assert.Equal(t, err, PodCreatorPortlayerClientError)
assert.Check(t, is.Nil(c), "Expected nil")
assert.Check(t, is.DeepEqual(err, PodCreatorPortlayerClientError))
c, err = NewPodCreator(client, nil, proxy, cache, persona, portlayer)
assert.Nil(t, c, "Expected nil")
assert.Equal(t, err, PodCreatorImageStoreError)
assert.Check(t, is.Nil(c), "Expected nil")
assert.Check(t, is.DeepEqual(err, PodCreatorImageStoreError))
c, err = NewPodCreator(client, store, nil, cache, persona, portlayer)
assert.Nil(t, c, "Expected nil")
assert.Equal(t, err, PodCreatorIsolationProxyError)
assert.Check(t, is.Nil(c), "Expected nil")
assert.Check(t, is.DeepEqual(err, PodCreatorIsolationProxyError))
c, err = NewPodCreator(client, store, proxy, nil, persona, portlayer)
assert.Nil(t, c, "Expected nil")
assert.Equal(t, err, PodCreatorPodCacheError)
assert.Check(t, is.Nil(c), "Expected nil")
assert.Check(t, is.DeepEqual(err, PodCreatorPodCacheError))
}
func TestCreatePod_NilPod(t *testing.T) {
@@ -52,10 +53,10 @@ func TestCreatePod_NilPod(t *testing.T) {
// Create nil pod
c, err := NewPodCreator(client, store, ip, cache, persona, portlayer)
assert.NotNil(t, c, "Expected not-nil creating a pod creator but received nil")
assert.Check(t, c != nil, "Expected not-nil creating a pod creator but received nil")
err = c.CreatePod(op, nil, true)
assert.NotNil(t, err, "Expected error from createPod but received '%s'", err)
assert.Check(t, err != nil, "Expected error from createPod but received '%s'", err)
}
func TestCreatePod_Success(t *testing.T) {
@@ -84,10 +85,10 @@ func TestCreatePod_Success(t *testing.T) {
// The test
c, err := NewPodCreator(client, store, ip, cache, persona, portlayer)
assert.NotNil(t, c, "Expected not-nil creating a pod creator but received nil")
assert.Check(t, c != nil, "Expected not-nil creating a pod creator but received nil")
err = c.CreatePod(op, &pod, true)
assert.Nil(t, err, "Expected error from createPod but received '%s'", err)
assert.Check(t, err, "Expected error from createPod but received '%s'", err)
}
func TestCreatePod_ImageStoreError(t *testing.T) {
@@ -117,10 +118,10 @@ func TestCreatePod_ImageStoreError(t *testing.T) {
// The test
c, err := NewPodCreator(client, store, ip, cache, persona, portlayer)
assert.NotNil(t, c, "Expected not-nil creating a pod creator but received nil")
assert.Check(t, c != nil, "Expected not-nil creating a pod creator but received nil")
err = c.CreatePod(op, &pod, true)
assert.NotNil(t, err, "Expected nil error from createPod")
assert.Check(t, err != nil, "Expected nil error from createPod")
}
func TestCreatePod_CreateHandleError(t *testing.T) {
@@ -150,11 +151,11 @@ func TestCreatePod_CreateHandleError(t *testing.T) {
// The test
c, err := NewPodCreator(client, store, ip, cache, persona, portlayer)
assert.NotNil(t, c, "Expected not-nil creating a pod creator but received nil")
assert.Check(t, c != nil, "Expected not-nil creating a pod creator but received nil")
err = c.CreatePod(op, &pod, true)
assert.NotNil(t, err, "Expected nil error from createPod")
assert.Equal(t, err.Error(), fakeErr.Error())
assert.Check(t, err != nil, "Expected nil error from createPod")
assert.Check(t, is.Equal(err.Error(), fakeErr.Error()))
}
func TestCreatePod_AddImageError(t *testing.T) {
@@ -184,11 +185,11 @@ func TestCreatePod_AddImageError(t *testing.T) {
// The test
c, err := NewPodCreator(client, store, ip, cache, persona, portlayer)
assert.NotNil(t, c, "Expected not-nil creating a pod creator but received nil")
assert.Check(t, c != nil, "Expected not-nil creating a pod creator but received nil")
err = c.CreatePod(op, &pod, true)
assert.NotNil(t, err, "Expected nil error from createPod")
assert.Equal(t, err.Error(), fakeErr.Error())
assert.Check(t, err != nil, "Expected nil error from createPod")
assert.Check(t, is.Equal(err.Error(), fakeErr.Error()))
}
func TestCreatePod_CreateHandleTaskError(t *testing.T) {
@@ -218,11 +219,11 @@ func TestCreatePod_CreateHandleTaskError(t *testing.T) {
// The test
c, err := NewPodCreator(client, store, ip, cache, persona, portlayer)
assert.NotNil(t, c, "Expected not-nil creating a pod creator but received nil")
assert.Check(t, c != nil, "Expected not-nil creating a pod creator but received nil")
err = c.CreatePod(op, &pod, true)
assert.NotNil(t, err, "Expected nil error from createPod")
assert.Equal(t, err.Error(), fakeErr.Error())
assert.Check(t, err != nil, "Expected nil error from createPod")
assert.Check(t, is.Equal(err.Error(), fakeErr.Error()))
}
func TestCreatePod_AddHandleToScopeError(t *testing.T) {
@@ -252,11 +253,11 @@ func TestCreatePod_AddHandleToScopeError(t *testing.T) {
// The test
c, err := NewPodCreator(client, store, ip, cache, persona, portlayer)
assert.NotNil(t, c, "Expected not-nil creating a pod creator but received nil")
assert.Check(t, c != nil, "Expected not-nil creating a pod creator but received nil")
err = c.CreatePod(op, &pod, true)
assert.NotNil(t, err, "Expected nil error from createPod")
assert.Equal(t, err.Error(), fakeErr.Error())
assert.Check(t, err != nil, "Expected nil error from createPod")
assert.Check(t, is.Equal(err.Error(), fakeErr.Error()))
}
func TestCreatePod_AddInteractionError(t *testing.T) {
@@ -286,11 +287,11 @@ func TestCreatePod_AddInteractionError(t *testing.T) {
// The test
c, err := NewPodCreator(client, store, ip, cache, persona, portlayer)
assert.NotNil(t, c, "Expected not-nil creating a pod creator but received nil")
assert.Check(t, c != nil, "Expected not-nil creating a pod creator but received nil")
err = c.CreatePod(op, &pod, true)
assert.NotNil(t, err, "Expected nil error from createPod")
assert.Equal(t, err.Error(), fakeErr.Error())
assert.Check(t, err != nil, "Expected nil error from createPod")
assert.Check(t, is.Equal(err.Error(), fakeErr.Error()))
}
func TestCreatePod_AddLoggingError(t *testing.T) {
@@ -320,11 +321,11 @@ func TestCreatePod_AddLoggingError(t *testing.T) {
// The test
c, err := NewPodCreator(client, store, ip, cache, persona, portlayer)
assert.NotNil(t, c, "Expected not-nil creating a pod creator but received nil")
assert.Check(t, c != nil, "Expected not-nil creating a pod creator but received nil")
err = c.CreatePod(op, &pod, true)
assert.NotNil(t, err, "Expected nil error from createPod")
assert.Equal(t, err.Error(), fakeErr.Error())
assert.Check(t, err != nil, "Expected nil error from createPod")
assert.Check(t, is.Equal(err.Error(), fakeErr.Error()))
}
func TestCreatePod_CommitError(t *testing.T) {
@@ -354,11 +355,11 @@ func TestCreatePod_CommitError(t *testing.T) {
// The test
c, err := NewPodCreator(client, store, ip, cache, persona, portlayer)
assert.NotNil(t, c, "Expected not-nil creating a pod creator but received nil")
assert.Check(t, c != nil, "Expected not-nil creating a pod creator but received nil")
err = c.CreatePod(op, &pod, true)
assert.NotNil(t, err, "Expected nil error from createPod")
assert.Equal(t, err.Error(), fakeErr.Error())
assert.Check(t, err != nil, "Expected nil error from createPod")
assert.Check(t, is.Equal(err.Error(), fakeErr.Error()))
}
func TestCreatePod_HandleError(t *testing.T) {
@@ -388,11 +389,11 @@ func TestCreatePod_HandleError(t *testing.T) {
// The test
c, err := NewPodCreator(client, store, ip, cache, persona, portlayer)
assert.NotNil(t, c, "Expected not-nil creating a pod creator but received nil")
assert.Check(t, c != nil, "Expected not-nil creating a pod creator but received nil")
err = c.CreatePod(op, &pod, true)
assert.NotNil(t, err, "Expected nil error from createPod")
assert.Equal(t, err.Error(), fakeErr.Error())
assert.Check(t, err != nil, "Expected nil error from createPod")
assert.Check(t, is.Equal(err.Error(), fakeErr.Error()))
}
func TestCreatePod_BindScopeError(t *testing.T) {
@@ -423,11 +424,11 @@ func TestCreatePod_BindScopeError(t *testing.T) {
// The test
c, err := NewPodCreator(client, store, ip, cache, persona, portlayer)
assert.NotNil(t, c, "Expected not-nil creating a pod creator but received nil")
assert.Check(t, c != nil, "Expected not-nil creating a pod creator but received nil")
err = c.CreatePod(op, &pod, true)
assert.NotNil(t, err, "Expected nil error from createPod")
assert.Equal(t, err.Error(), fakeErr.Error())
assert.Check(t, err != nil, "Expected nil error from createPod")
assert.Check(t, is.Equal(err.Error(), fakeErr.Error()))
}
func TestCreatePod_SetStateError(t *testing.T) {
@@ -458,9 +459,9 @@ func TestCreatePod_SetStateError(t *testing.T) {
// The test
c, err := NewPodCreator(client, store, ip, cache, persona, portlayer)
assert.NotNil(t, c, "Expected not-nil creating a pod creator but received nil")
assert.Check(t, c != nil, "Expected not-nil creating a pod creator but received nil")
err = c.CreatePod(op, &pod, true)
assert.NotNil(t, err, "Expected nil error from createPod")
assert.Equal(t, err.Error(), fakeErr.Error())
assert.Check(t, err != nil, "Expected nil error from createPod")
assert.Check(t, is.Equal(err.Error(), fakeErr.Error()))
}

58
providers/vic/operations/pod_deleter_test.go
View File

@@ -3,9 +3,9 @@ package operations
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/vmware/vic/lib/apiservers/portlayer/client"
"gotest.tools/assert"
is "gotest.tools/assert/cmp"
)
func init() {
@@ -20,20 +20,20 @@ func TestNewPodDeleter(t *testing.T) {
// Positive Cases
d, err := NewPodDeleter(client, ip, cache, persona, portlayer)
assert.NotNil(t, d, "Expected non-nil creating a pod Deleter but received nil")
assert.Check(t, d != nil, "Expected non-nil creating a pod Deleter but received nil")
// Negative Cases
d, err = NewPodDeleter(nil, ip, cache, persona, portlayer)
assert.Nil(t, d, "Expected nil")
assert.Equal(t, err, PodDeleterPortlayerClientError)
assert.Check(t, is.Nil(d), "Expected nil")
assert.Check(t, is.DeepEqual(err, PodDeleterPortlayerClientError))
d, err = NewPodDeleter(client, nil, cache, persona, portlayer)
assert.Nil(t, d, "Expected nil")
assert.Equal(t, err, PodDeleterIsolationProxyError)
assert.Check(t, is.Nil(d), "Expected nil")
assert.Check(t, is.DeepEqual(err, PodDeleterIsolationProxyError))
d, err = NewPodDeleter(client, ip, nil, persona, portlayer)
assert.Nil(t, d, "Expected nil")
assert.Equal(t, err, PodDeleterPodCacheError)
assert.Check(t, is.Nil(d), "Expected nil")
assert.Check(t, is.DeepEqual(err, PodDeleterPodCacheError))
}
func TestDeletePod(t *testing.T) {
@@ -44,8 +44,8 @@ func TestDeletePod(t *testing.T) {
portlayer := "1.2.3.4"
d, err := NewPodDeleter(client, ip, cache, persona, portlayer)
assert.NotNil(t, d, "Expected non-nil creating a pod Deleter but received nil")
assert.Nil(t, err, "Expected nil")
assert.Check(t, d != nil, "Expected non-nil creating a pod Deleter but received nil")
assert.Check(t, err, "Expected nil")
// Set up the mocks for this test
ip.On("Handle", op, podID, podName).Return(podHandle, nil)
@@ -59,7 +59,7 @@ func TestDeletePod(t *testing.T) {
// Positive case
err = d.DeletePod(op, &pod)
assert.Nil(t, err, "Expected nil")
assert.Check(t, err, "Expected nil")
}
func TestDeletePodErrorHandle(t *testing.T) {
@@ -70,8 +70,8 @@ func TestDeletePodErrorHandle(t *testing.T) {
portlayer := "1.2.3.4"
d, err := NewPodDeleter(client, ip, cache, persona, portlayer)
assert.NotNil(t, d, "Expected non-nil creating a pod Deleter but received nil")
assert.Nil(t, err, "Expected nil")
assert.Check(t, d != nil, "Expected non-nil creating a pod Deleter but received nil")
assert.Check(t, err, "Expected nil")
// Set up the mocks for this test
ip.On("UnbindScope", op, podHandle, podName).Return(podHandle, fakeEP, nil)
@@ -87,7 +87,7 @@ func TestDeletePodErrorHandle(t *testing.T) {
ip.On("Handle", op, podID, podName).Return("", fakeErr)
err = d.DeletePod(op, &pod)
assert.Equal(t, err, fakeErr, "Expected invalid handle error")
assert.Check(t, is.Error(err, fakeErr.Error()), "Expected invalid handle error")
}
func TestDeletePodErrorUnbindScope(t *testing.T) {
@@ -98,8 +98,8 @@ func TestDeletePodErrorUnbindScope(t *testing.T) {
portlayer := "1.2.3.4"
d, err := NewPodDeleter(client, ip, cache, persona, portlayer)
assert.NotNil(t, d, "Expected non-nil creating a pod Deleter but received nil")
assert.Nil(t, err, "Expected nil")
assert.Check(t, d != nil, "Expected non-nil creating a pod Deleter but received nil")
assert.Check(t, err, "Expected nil")
// Set up the mocks for this test
ip.On("Handle", op, podID, podName).Return(podHandle, nil)
@@ -114,7 +114,7 @@ func TestDeletePodErrorUnbindScope(t *testing.T) {
ip.On("UnbindScope", op, podHandle, podName).Return("", nil, fakeErr)
err = d.DeletePod(op, &pod)
assert.Equal(t, err, fakeErr, "Expected failed UnbindScope error")
assert.Check(t, is.Error(err, fakeErr.Error()), "Expected failed UnbindScope error")
}
func TestDeletePodErrorSetState(t *testing.T) {
@@ -125,8 +125,8 @@ func TestDeletePodErrorSetState(t *testing.T) {
portlayer := "1.2.3.4"
d, err := NewPodDeleter(client, ip, cache, persona, portlayer)
assert.NotNil(t, d, "Expected non-nil creating a pod Deleter but received nil")
assert.Nil(t, err, "Expected nil")
assert.Check(t, d != nil, "Expected non-nil creating a pod Deleter but received nil")
assert.Check(t, err, "Expected nil")
// Set up the mocks for this test
ip.On("Handle", op, podID, podName).Return(podHandle, nil)
@@ -141,7 +141,7 @@ func TestDeletePodErrorSetState(t *testing.T) {
fakeErr := fakeError("failed SetState")
ip.On("SetState", op, podHandle, podName, "STOPPED").Return("", fakeErr)
err = d.DeletePod(op, &pod)
assert.Equal(t, err, fakeErr, "Expected failed SetState error")
assert.Check(t, is.Error(err, fakeErr.Error()), "Expected failed SetState error")
}
func TestDeletePodErrorCommitHandle(t *testing.T) {
@@ -152,8 +152,8 @@ func TestDeletePodErrorCommitHandle(t *testing.T) {
portlayer := "1.2.3.4"
d, err := NewPodDeleter(client, ip, cache, persona, portlayer)
assert.NotNil(t, d, "Expected non-nil creating a pod Deleter but received nil")
assert.Nil(t, err, "Expected nil")
assert.Check(t, d != nil, "Expected non-nil creating a pod Deleter but received nil")
assert.Check(t, err, "Expected nil")
// Set up the mocks for this test
ip.On("Handle", op, podID, podName).Return(podHandle, nil)
@@ -167,7 +167,7 @@ func TestDeletePodErrorCommitHandle(t *testing.T) {
fakeErr := fakeError("failed Commit")
ip.On("CommitHandle", op, podHandle, podID, int32(-1)).Return(fakeErr)
err = d.DeletePod(op, &pod)
assert.Equal(t, err, fakeErr, "Expected failed Commit error")
assert.Check(t, is.Error(err, fakeErr.Error()), "Expected failed Commit error")
}
func TestDeletePodErrorRemove(t *testing.T) {
@@ -178,8 +178,8 @@ func TestDeletePodErrorRemove(t *testing.T) {
portlayer := "1.2.3.4"
d, err := NewPodDeleter(client, ip, cache, persona, portlayer)
assert.NotNil(t, d, "Expected non-nil creating a pod Deleter but received nil")
assert.Nil(t, err, "Expected nil")
assert.Check(t, d != nil, "Expected non-nil creating a pod Deleter but received nil")
assert.Check(t, err, "Expected nil")
// Set up the mocks for this test
ip.On("Handle", op, podID, podName).Return(podHandle, nil)
@@ -194,7 +194,7 @@ func TestDeletePodErrorRemove(t *testing.T) {
fakeErr := fakeError("failed Remove")
ip.On("Remove", op, podID, true).Return(fakeErr)
err = d.DeletePod(op, &pod)
assert.Equal(t, err, fakeErr, "Expected failed Remove error")
assert.Check(t, is.Error(err, fakeErr.Error()), "Expected failed Remove error")
}
func TestDeletePodErrorBadArgs(t *testing.T) {
@@ -204,9 +204,9 @@ func TestDeletePodErrorBadArgs(t *testing.T) {
portlayer := "1.2.3.4"
d, err := NewPodDeleter(client, ip, cache, persona, portlayer)
assert.NotNil(t, d, "Expected non-nil creating a pod Deleter but received nil")
assert.Check(t, d != nil, "Expected non-nil creating a pod Deleter but received nil")
// Negative Cases
err = d.DeletePod(op, nil)
assert.Equal(t, err, PodDeleterInvalidPodSpecError)
assert.Check(t, is.DeepEqual(err, PodDeleterInvalidPodSpecError))
}

14
providers/vic/operations/pod_starter_test.go
View File

@@ -3,10 +3,10 @@ package operations
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/virtual-kubelet/virtual-kubelet/providers/vic/proxy/mocks"
"github.com/vmware/vic/lib/apiservers/portlayer/client"
"gotest.tools/assert"
is "gotest.tools/assert/cmp"
)
func TestNewPodStarter(t *testing.T) {
@@ -18,16 +18,16 @@ func TestNewPodStarter(t *testing.T) {
// Positive Cases
s, err = NewPodStarter(client, ip)
assert.NotNil(t, s, "Expected non-nil creating a pod starter but received nil")
assert.Check(t, s != nil, "Expected non-nil creating a pod starter but received nil")
// Negative Cases
s, err = NewPodStarter(nil, ip)
assert.Nil(t, s, "Expected nil")
assert.Equal(t, err, PodStarterPortlayerClientError)
assert.Check(t, is.Nil(s), "Expected nil")
assert.Check(t, is.DeepEqual(err, PodStarterPortlayerClientError))
s, err = NewPodStarter(client, nil)
assert.Nil(t, s, "Expected nil")
assert.Equal(t, err, PodStarterIsolationProxyError)
assert.Check(t, is.Nil(s), "Expected nil")
assert.Check(t, is.DeepEqual(err, PodStarterIsolationProxyError))
}
//NOTE: The rest of PodStarter tests were handled in PodCreator's tests so there's no need for further tests.

98
providers/vic/operations/pod_status_test.go
View File

@@ -3,10 +3,10 @@ package operations
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/vmware/vic/lib/apiservers/portlayer/client"
"k8s.io/api/core/v1"
"gotest.tools/assert"
is "gotest.tools/assert/cmp"
v1 "k8s.io/api/core/v1"
)
func TestNewPodStatus(t *testing.T) {
@@ -15,16 +15,16 @@ func TestNewPodStatus(t *testing.T) {
// Positive Cases
s, err := NewPodStatus(client, ip)
assert.NotNil(t, s, "Expected non-nil creating a pod Status but received nil")
assert.Check(t, s != nil, "Expected non-nil creating a pod Status but received nil")
// Negative Cases
s, err = NewPodStatus(nil, ip)
assert.Nil(t, s, "Expected nil")
assert.Equal(t, err, PodStatusPortlayerClientError)
assert.Check(t, is.Nil(s), "Expected nil")
assert.Check(t, is.DeepEqual(err, PodStatusPortlayerClientError))
s, err = NewPodStatus(client, nil)
assert.Nil(t, s, "Expected nil")
assert.Equal(t, err, PodStatusIsolationProxyError)
assert.Check(t, is.Nil(s), "Expected nil")
assert.Check(t, is.DeepEqual(err, PodStatusIsolationProxyError))
}
func TestStatusPodStarting(t *testing.T) {
@@ -32,8 +32,8 @@ func TestStatusPodStarting(t *testing.T) {
_, ip, _, op := createMocks(t)
s, err := NewPodStatus(client, ip)
assert.NotNil(t, s, "Expected non-nil creating a pod Status but received nil")
assert.Nil(t, err, "Expected nil")
assert.Check(t, s != nil, "Expected non-nil creating a pod Status but received nil")
assert.Check(t, err, "Expected nil")
HostAddress := "1.2.3.4"
EndpointAddresses := []string{
@@ -46,11 +46,11 @@ func TestStatusPodStarting(t *testing.T) {
// Positive case
status, err := s.GetStatus(op, podID, podName, HostAddress)
assert.Nil(t, err, "Expected nil")
assert.Equal(t, status.Phase, v1.PodPending, "Expected Phase Pending")
assert.Check(t, err, "Expected nil")
assert.Check(t, is.Equal(status.Phase, v1.PodPending), "Expected Phase Pending")
verifyConditions(t, status.Conditions, v1.ConditionTrue, v1.ConditionFalse, v1.ConditionFalse)
assert.Equal(t, status.HostIP, "1.2.3.4", "Expected Host IP Address")
assert.Equal(t, status.PodIP, "5.6.7.8", "Expected Pod IP Address")
assert.Check(t, is.Equal(status.HostIP, "1.2.3.4"), "Expected Host IP Address")
assert.Check(t, is.Equal(status.PodIP, "5.6.7.8"), "Expected Pod IP Address")
}
func TestStatusPodRunning(t *testing.T) {
@@ -58,8 +58,8 @@ func TestStatusPodRunning(t *testing.T) {
_, ip, _, op := createMocks(t)
s, err := NewPodStatus(client, ip)
assert.NotNil(t, s, "Expected non-nil creating a pod Status but received nil")
assert.Nil(t, err, "Expected nil")
assert.Check(t, s != nil, "Expected non-nil creating a pod Status but received nil")
assert.Check(t, err, "Expected nil")
HostAddress := "1.2.3.4"
EndpointAddresses := []string{
@@ -72,11 +72,11 @@ func TestStatusPodRunning(t *testing.T) {
// Pod Running case
status, err := s.GetStatus(op, podID, podName, HostAddress)
assert.Nil(t, err, "Expected nil")
assert.Equal(t, status.Phase, v1.PodRunning, "Expected Phase PodRunning")
assert.Check(t, err, "Expected nil")
assert.Check(t, is.Equal(status.Phase, v1.PodRunning), "Expected Phase PodRunning")
verifyConditions(t, status.Conditions, v1.ConditionTrue, v1.ConditionTrue, v1.ConditionTrue)
assert.Equal(t, status.HostIP, "1.2.3.4", "Expected Host IP Address")
assert.Equal(t, status.PodIP, "5.6.7.8", "Expected Pod IP Address")
assert.Check(t, is.Equal(status.HostIP, "1.2.3.4"), "Expected Host IP Address")
assert.Check(t, is.Equal(status.PodIP, "5.6.7.8"), "Expected Pod IP Address")
}
func TestStatusPodStopping(t *testing.T) {
@@ -84,8 +84,8 @@ func TestStatusPodStopping(t *testing.T) {
_, ip, _, op := createMocks(t)
s, err := NewPodStatus(client, ip)
assert.NotNil(t, s, "Expected non-nil creating a pod Status but received nil")
assert.Nil(t, err, "Expected nil")
assert.Check(t, s != nil, "Expected non-nil creating a pod Status but received nil")
assert.Check(t, err, "Expected nil")
HostAddress := "1.2.3.4"
EndpointAddresses := []string{
@@ -99,10 +99,10 @@ func TestStatusPodStopping(t *testing.T) {
// Pod error case
status, err := s.GetStatus(op, podID, podName, HostAddress)
assert.Equal(t, status.Phase, v1.PodRunning, "Expected Phase PodFailed")
assert.Check(t, is.Equal(status.Phase, v1.PodRunning), "Expected Phase PodFailed")
verifyConditions(t, status.Conditions, v1.ConditionTrue, v1.ConditionTrue, v1.ConditionFalse)
assert.Equal(t, status.HostIP, "1.2.3.4", "Expected Host IP Address")
assert.Equal(t, status.PodIP, "5.6.7.8", "Expected Pod IP Address")
assert.Check(t, is.Equal(status.HostIP, "1.2.3.4"), "Expected Host IP Address")
assert.Check(t, is.Equal(status.PodIP, "5.6.7.8"), "Expected Pod IP Address")
}
func TestStatusPodStopped(t *testing.T) {
@@ -110,8 +110,8 @@ func TestStatusPodStopped(t *testing.T) {
_, ip, _, op := createMocks(t)
s, err := NewPodStatus(client, ip)
assert.NotNil(t, s, "Expected non-nil creating a pod Status but received nil")
assert.Nil(t, err, "Expected nil")
assert.Check(t, s != nil, "Expected non-nil creating a pod Status but received nil")
assert.Check(t, err, "Expected nil")
HostAddress := "1.2.3.4"
EndpointAddresses := []string{
@@ -125,10 +125,10 @@ func TestStatusPodStopped(t *testing.T) {
// Pod error case
status, err := s.GetStatus(op, podID, podName, HostAddress)
assert.Equal(t, status.Phase, v1.PodSucceeded, "Expected Phase PodFailed")
assert.Check(t, is.Equal(status.Phase, v1.PodSucceeded), "Expected Phase PodFailed")
verifyConditions(t, status.Conditions, v1.ConditionTrue, v1.ConditionTrue, v1.ConditionFalse)
assert.Equal(t, status.HostIP, "1.2.3.4", "Expected Host IP Address")
assert.Equal(t, status.PodIP, "5.6.7.8", "Expected Pod IP Address")
assert.Check(t, is.Equal(status.HostIP, "1.2.3.4"), "Expected Host IP Address")
assert.Check(t, is.Equal(status.PodIP, "5.6.7.8"), "Expected Pod IP Address")
}
func TestStatusPodRemoving(t *testing.T) {
@@ -136,8 +136,8 @@ func TestStatusPodRemoving(t *testing.T) {
_, ip, _, op := createMocks(t)
s, err := NewPodStatus(client, ip)
assert.NotNil(t, s, "Expected non-nil creating a pod Status but received nil")
assert.Nil(t, err, "Expected nil")
assert.Check(t, s != nil, "Expected non-nil creating a pod Status but received nil")
assert.Check(t, err, "Expected nil")
HostAddress := "1.2.3.4"
EndpointAddresses := []string{
@@ -151,10 +151,10 @@ func TestStatusPodRemoving(t *testing.T) {
// Pod error case
status, err := s.GetStatus(op, podID, podName, HostAddress)
assert.Equal(t, status.Phase, v1.PodSucceeded, "Expected Phase PodFailed")
assert.Check(t, is.Equal(status.Phase, v1.PodSucceeded), "Expected Phase PodFailed")
verifyConditions(t, status.Conditions, v1.ConditionTrue, v1.ConditionTrue, v1.ConditionFalse)
assert.Equal(t, status.HostIP, "1.2.3.4", "Expected Host IP Address")
assert.Equal(t, status.PodIP, "5.6.7.8", "Expected Pod IP Address")
assert.Check(t, is.Equal(status.HostIP, "1.2.3.4"), "Expected Host IP Address")
assert.Check(t, is.Equal(status.PodIP, "5.6.7.8"), "Expected Pod IP Address")
}
func TestStatusPodRemoved(t *testing.T) {
@@ -162,8 +162,8 @@ func TestStatusPodRemoved(t *testing.T) {
_, ip, _, op := createMocks(t)
s, err := NewPodStatus(client, ip)
assert.NotNil(t, s, "Expected non-nil creating a pod Status but received nil")
assert.Nil(t, err, "Expected nil")
assert.Check(t, s != nil, "Expected non-nil creating a pod Status but received nil")
assert.Check(t, err, "Expected nil")
HostAddress := "1.2.3.4"
EndpointAddresses := []string{
@@ -177,10 +177,10 @@ func TestStatusPodRemoved(t *testing.T) {
// Pod error case
status, err := s.GetStatus(op, podID, podName, HostAddress)
assert.Equal(t, status.Phase, v1.PodSucceeded, "Expected Phase PodFailed")
assert.Check(t, is.Equal(status.Phase, v1.PodSucceeded), "Expected Phase PodFailed")
verifyConditions(t, status.Conditions, v1.ConditionTrue, v1.ConditionTrue, v1.ConditionFalse)
assert.Equal(t, status.HostIP, "1.2.3.4", "Expected Host IP Address")
assert.Equal(t, status.PodIP, "5.6.7.8", "Expected Pod IP Address")
assert.Check(t, is.Equal(status.HostIP, "1.2.3.4"), "Expected Host IP Address")
assert.Check(t, is.Equal(status.PodIP, "5.6.7.8"), "Expected Pod IP Address")
}
func TestStatusError(t *testing.T) {
@@ -189,8 +189,8 @@ func TestStatusError(t *testing.T) {
// Start with arguments
s, err := NewPodStatus(client, ip)
assert.NotNil(t, s, "Expected non-nil creating a pod Status but received nil")
assert.Nil(t, err, "Expected nil")
assert.Check(t, s != nil, "Expected non-nil creating a pod Status but received nil")
assert.Check(t, err, "Expected nil")
HostAddress := "0.0.0.0"
@@ -201,24 +201,24 @@ func TestStatusError(t *testing.T) {
// Error case
status, err := s.GetStatus(op, podID, podName, HostAddress)
assert.Nil(t, err, "Expected nil")
assert.Equal(t, status.Phase, v1.PodUnknown, "Expected Phase PodUnknown")
assert.Check(t, err, "Expected nil")
assert.Check(t, is.Equal(status.Phase, v1.PodUnknown), "Expected Phase PodUnknown")
verifyConditions(t, status.Conditions, v1.ConditionUnknown, v1.ConditionUnknown, v1.ConditionUnknown)
assert.Equal(t, status.HostIP, "0.0.0.0", "Expected Host IP Address")
assert.Equal(t, status.PodIP, "0.0.0.0", "Expected Pod IP Address")
assert.Check(t, is.Equal(status.HostIP, "0.0.0.0"), "Expected Host IP Address")
assert.Check(t, is.Equal(status.PodIP, "0.0.0.0"), "Expected Pod IP Address")
}
func verifyConditions(t *testing.T, conditions []v1.PodCondition, scheduled v1.ConditionStatus, initialized v1.ConditionStatus, ready v1.ConditionStatus) {
for _, condition := range conditions {
switch condition.Type {
case v1.PodScheduled:
assert.Equal(t, condition.Status, scheduled, "Condition Pod Scheduled")
assert.Check(t, is.Equal(condition.Status, scheduled), "Condition Pod Scheduled")
break
case v1.PodInitialized:
assert.Equal(t, condition.Status, initialized, "Condition Pod Initialized")
assert.Check(t, is.Equal(condition.Status, initialized), "Condition Pod Initialized")
break
case v1.PodReady:
assert.Equal(t, condition.Status, ready, "Condition Pod Ready")
assert.Check(t, is.Equal(condition.Status, ready), "Condition Pod Ready")
break
}
}

46
providers/vic/operations/pod_stopper_test.go
View File

@@ -3,9 +3,9 @@ package operations
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/vmware/vic/lib/apiservers/portlayer/client"
"gotest.tools/assert"
is "gotest.tools/assert/cmp"
)
func TestNewPodStopper(t *testing.T) {
@@ -14,16 +14,16 @@ func TestNewPodStopper(t *testing.T) {
// Positive Cases
s, err := NewPodStopper(client, ip)
assert.NotNil(t, s, "Expected non-nil creating a pod Stopper but received nil")
assert.Check(t, s != nil, "Expected non-nil creating a pod Stopper but received nil")
// Negative Cases
s, err = NewPodStopper(nil, ip)
assert.Nil(t, s, "Expected nil")
assert.Equal(t, err, PodStopperPortlayerClientError)
assert.Check(t, is.Nil(s), "Expected nil")
assert.Check(t, is.DeepEqual(err, PodStopperPortlayerClientError))
s, err = NewPodStopper(client, nil)
assert.Nil(t, s, "Expected nil")
assert.Equal(t, err, PodStopperIsolationProxyError)
assert.Check(t, is.Nil(s), "Expected nil")
assert.Check(t, is.DeepEqual(err, PodStopperIsolationProxyError))
}
func TestStopPod(t *testing.T) {
@@ -32,8 +32,8 @@ func TestStopPod(t *testing.T) {
// Start with arguments
s, err := NewPodStopper(client, ip)
assert.NotNil(t, s, "Expected non-nil creating a pod Stopper but received nil")
assert.Nil(t, err, "Expected nil")
assert.Check(t, s != nil, "Expected non-nil creating a pod Stopper but received nil")
assert.Check(t, err, "Expected nil")
// Set up the mocks for this test
ip.On("Handle", op, podID, podName).Return(podHandle, nil)
@@ -43,7 +43,7 @@ func TestStopPod(t *testing.T) {
// Positive case
err = s.Stop(op, podID, podName)
assert.Nil(t, err, "Expected nil")
assert.Check(t, err, "Expected nil")
}
func TestStopPodErrorHandle(t *testing.T) {
@@ -52,8 +52,8 @@ func TestStopPodErrorHandle(t *testing.T) {
// Start with arguments
s, err := NewPodStopper(client, ip)
assert.NotNil(t, s, "Expected non-nil creating a pod Stopper but received nil")
assert.Nil(t, err, "Expected nil")
assert.Check(t, s != nil, "Expected non-nil creating a pod Stopper but received nil")
assert.Check(t, err, "Expected nil")
// Set up the mocks for this test
ip.On("UnbindScope", op, podHandle, podName).Return(podHandle, fakeEP, nil)
@@ -65,7 +65,7 @@ func TestStopPodErrorHandle(t *testing.T) {
ip.On("Handle", op, podID, podName).Return("", fakeErr)
err = s.Stop(op, podID, podName)
assert.Equal(t, err, fakeErr, "Expected invalid handle error")
assert.Check(t, is.Error(err, fakeErr.Error()), "Expected invalid handle error")
}
func TestStopPodErrorUnbindScope(t *testing.T) {
@@ -74,8 +74,8 @@ func TestStopPodErrorUnbindScope(t *testing.T) {
// Start with arguments
s, err := NewPodStopper(client, ip)
assert.NotNil(t, s, "Expected non-nil creating a pod Stopper but received nil")
assert.Nil(t, err, "Expected nil")
assert.Check(t, s != nil, "Expected non-nil creating a pod Stopper but received nil")
assert.Check(t, err, "Expected nil")
// Set up the mocks for this test
ip.On("Handle", op, podID, podName).Return(podHandle, nil)
@@ -87,7 +87,7 @@ func TestStopPodErrorUnbindScope(t *testing.T) {
ip.On("UnbindScope", op, podHandle, podName).Return("", nil, fakeErr)
err = s.Stop(op, podID, podName)
assert.Equal(t, err, fakeErr, "Expected failed UnbindScope error")
assert.Check(t, is.Error(err, fakeErr.Error()), "Expected failed UnbindScope error")
}
func TestStopPodErrorSetState(t *testing.T) {
@@ -96,8 +96,8 @@ func TestStopPodErrorSetState(t *testing.T) {
// Start with arguments
s, err := NewPodStopper(client, ip)
assert.NotNil(t, s, "Expected non-nil creating a pod Stopper but received nil")
assert.Nil(t, err, "Expected nil")
assert.Check(t, s != nil, "Expected non-nil creating a pod Stopper but received nil")
assert.Check(t, err, "Expected nil")
// Set up the mocks for this test
ip.On("Handle", op, podID, podName).Return(podHandle, nil)
@@ -108,7 +108,7 @@ func TestStopPodErrorSetState(t *testing.T) {
fakeErr := fakeError("failed SetState")
ip.On("SetState", op, podHandle, podName, "STOPPED").Return("", fakeErr)
err = s.Stop(op, podID, podName)
assert.Equal(t, err, fakeErr, "Expected failed SetState error")
assert.Check(t, is.Error(err, fakeErr.Error()), "Expected failed SetState error")
}
func TestStopPodErrorCommit(t *testing.T) {
@@ -117,8 +117,8 @@ func TestStopPodErrorCommit(t *testing.T) {
// Start with arguments
s, err := NewPodStopper(client, ip)
assert.NotNil(t, s, "Expected non-nil creating a pod Stopper but received nil")
assert.Nil(t, err, "Expected nil")
assert.Check(t, s != nil, "Expected non-nil creating a pod Stopper but received nil")
assert.Check(t, err, "Expected nil")
// Set up the mocks for this test
ip.On("Handle", op, podID, podName).Return(podHandle, nil)
@@ -129,5 +129,5 @@ func TestStopPodErrorCommit(t *testing.T) {
fakeErr := fakeError("failed Commit")
ip.On("CommitHandle", op, podHandle, podID, int32(-1)).Return(fakeErr)
err = s.Stop(op, podID, podName)
assert.Equal(t, err, fakeErr ,"Expected failed Commit error")
}
assert.Check(t, is.Error(err, fakeErr.Error()), "Expected failed Commit error")
}

31
providers/vic/utils/units_test.go
View File

@@ -3,51 +3,52 @@ package utils
import (
"testing"
"github.com/stretchr/testify/require"
"strings"
"gotest.tools/assert"
)
func TestMemoryConversion(t *testing.T) {
memSize := MemsizeToBinaryString(2, "Gb")
require.True(t, memSize == "2048Mi")
assert.Assert(t, memSize == "2048Mi")
memSize = MemsizeToDecimalString(2, "Gb")
require.True(t, memSize == "2147M")
assert.Assert(t, memSize == "2147M")
memSize = MemsizeToBinaryString(2048, "Mb")
require.True(t, memSize == "2048Mi")
assert.Assert(t, memSize == "2048Mi")
memSize = MemsizeToDecimalString(2048, "Mb")
require.True(t, memSize == "2147M")
assert.Assert(t, memSize == "2147M")
memSize = MemsizeToBinaryString(2048*1024, "Kb")
require.True(t, memSize == "2048Mi")
assert.Assert(t, memSize == "2048Mi")
memSize = MemsizeToDecimalString(2048*1024, "Kb")
require.True(t, memSize == "2147M")
assert.Assert(t, memSize == "2147M")
memSize = MemsizeToBinaryString(MEMORYCUTOVER, "Gb")
require.True(t, memSize == "100Gi")
assert.Assert(t, memSize == "100Gi")
memSize = MemsizeToBinaryString(MEMORYCUTOVER-1, "Gb")
strings.HasSuffix(memSize, "Mi")
require.True(t, strings.HasSuffix(memSize, "Mi"))
assert.Assert(t, strings.HasSuffix(memSize, "Mi"))
memSize = MemsizeToBinaryString((MEMORYCUTOVER-1)*1024, "Mb")
require.True(t, strings.HasSuffix(memSize, "Mi"))
assert.Assert(t, strings.HasSuffix(memSize, "Mi"))
memSize = MemsizeToDecimalString(MEMORYCUTOVER*1000000000, "b")
require.True(t, memSize == "100G")
assert.Assert(t, memSize == "100G")
memSize = MemsizeToDecimalString((MEMORYCUTOVER-1)*1000000000, "b")
require.True(t, strings.HasSuffix(memSize, "M"))
assert.Assert(t, strings.HasSuffix(memSize, "M"))
}
func TestFrequencyConversion(t *testing.T) {
feq := CpuFrequencyToString(FREQUENCYCUTOVER, "Ghz")
require.True(t, feq == "10G")
assert.Assert(t, feq == "10G")
feq = CpuFrequencyToString(FREQUENCYCUTOVER-1, "Ghz")
require.True(t, feq == "9000M")
assert.Assert(t, feq == "9000M")
feq = CpuFrequencyToString((FREQUENCYCUTOVER-1)*1000, "Mhz")
require.True(t, feq == "9000M")
assert.Assert(t, feq == "9000M")
}