From 947b530f1ec90ad8e842029182d9a2cd81681955 Mon Sep 17 00:00:00 2001 From: Brian Goff Date: Thu, 28 Mar 2019 17:08:12 -0700 Subject: [PATCH] Replace testify with gotest.tools (#553) * vendor gotest.tools * Run gotest.tools migration tools * Fixup tests that were improperly converted * Remove unused testify package vendors --- Gopkg.lock | 6 +- Gopkg.toml | 4 + providers/aws/fargate/container_test.go | 112 +-- providers/aws/fargate/pod_test.go | 16 +- providers/azure/aci_test.go | 233 +++-- providers/huawei/cci_test.go | 53 +- providers/nomad/nomad_test.go | 13 +- providers/vic/cache/pod_cache_test.go | 52 +- providers/vic/operations/pod_creator_test.go | 93 +- providers/vic/operations/pod_deleter_test.go | 58 +- providers/vic/operations/pod_starter_test.go | 14 +- providers/vic/operations/pod_status_test.go | 98 +- providers/vic/operations/pod_stopper_test.go | 46 +- providers/vic/utils/units_test.go | 31 +- .../stretchr/testify/require/doc.go | 28 - .../testify/require/forward_requirements.go | 16 - .../stretchr/testify/require/require.go | 867 ------------------ .../testify/require/require_forward.go | 687 -------------- .../stretchr/testify/require/requirements.go | 9 - vkubelet/env_internal_test.go | 137 +-- 20 files changed, 484 insertions(+), 2089 deletions(-) delete mode 100644 vendor/github.com/stretchr/testify/require/doc.go delete mode 100644 vendor/github.com/stretchr/testify/require/forward_requirements.go delete mode 100644 vendor/github.com/stretchr/testify/require/require.go delete mode 100644 vendor/github.com/stretchr/testify/require/require_forward.go delete mode 100644 vendor/github.com/stretchr/testify/require/requirements.go diff --git a/Gopkg.lock b/Gopkg.lock index f2b758068..0e17d2c6e 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -24,6 +24,7 @@ packages = [ "services/batch/2017-09-01.6.0/batch", "services/network/mgmt/2018-08-01/network", + "services/preview/servicefabricmesh/mgmt/2018-07-01-preview/servicefabricmesh", "version", ] pruneopts = "NUT" @@ -1054,7 +1055,7 @@ version = "v0.1" [[projects]] - digest = "1:d4de0b9ca757efa67bf8f0f0ee664ad4dc7e11fbad7dd38db4e403ad9b92fe3c" + digest = "1:6a02f7a43a434d20225f8fef98694f3ceda5a3dad2376ffb07e3b2f201fab9a3" name = "github.com/stretchr/testify" packages = [ "assert", @@ -1807,6 +1808,7 @@ "github.com/cpuguy83/strongerrors/status", "github.com/cpuguy83/strongerrors/status/ocstatus", "github.com/docker/docker/api/types/strslice", + "github.com/google/go-cmp/cmp", "github.com/google/uuid", "github.com/gorilla/mux", "github.com/gorilla/websocket", @@ -1818,9 +1820,7 @@ "github.com/pkg/errors", "github.com/spf13/cobra", "github.com/spf13/viper", - "github.com/stretchr/testify/assert", "github.com/stretchr/testify/mock", - "github.com/stretchr/testify/require", "github.com/virtual-kubelet/azure-aci/client", "github.com/virtual-kubelet/azure-aci/client/aci", "github.com/virtual-kubelet/azure-aci/client/api", diff --git a/Gopkg.toml b/Gopkg.toml index adc7b82ec..bb81ad388 100644 --- a/Gopkg.toml +++ b/Gopkg.toml @@ -137,3 +137,7 @@ name = "github.com/virtual-kubelet/azure-aci" version = "v0.1.0" + +[[constraint]] + name = "gotest.tools" + version = "2.3.0" diff --git a/providers/aws/fargate/container_test.go b/providers/aws/fargate/container_test.go index 5700885d3..9dd97336b 100644 --- a/providers/aws/fargate/container_test.go +++ b/providers/aws/fargate/container_test.go @@ -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") } diff --git a/providers/aws/fargate/pod_test.go b/providers/aws/fargate/pod_test.go index 4482ec53b..4e60c7b2d 100644 --- a/providers/aws/fargate/pod_test.go +++ b/providers/aws/fargate/pod_test.go @@ -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) diff --git a/providers/azure/aci_test.go b/providers/azure/aci_test.go index 129b78a7c..4c8542fbc 100644 --- a/providers/azure/aci_test.go +++ b/providers/azure/aci_test.go @@ -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 } diff --git a/providers/huawei/cci_test.go b/providers/huawei/cci_test.go index 57893cf75..0ac8beefe 100644 --- a/providers/huawei/cci_test.go +++ b/providers/huawei/cci_test.go @@ -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) { diff --git a/providers/nomad/nomad_test.go b/providers/nomad/nomad_test.go index cea8ea604..765d7ca1a 100644 --- a/providers/nomad/nomad_test.go +++ b/providers/nomad/nomad_test.go @@ -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) diff --git a/providers/vic/cache/pod_cache_test.go b/providers/vic/cache/pod_cache_test.go index 8119a38f8..400b484e0 100644 --- a/providers/vic/cache/pod_cache_test.go +++ b/providers/vic/cache/pod_cache_test.go @@ -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") } - diff --git a/providers/vic/operations/pod_creator_test.go b/providers/vic/operations/pod_creator_test.go index 8e76d2105..7b391f842 100644 --- a/providers/vic/operations/pod_creator_test.go +++ b/providers/vic/operations/pod_creator_test.go @@ -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())) } diff --git a/providers/vic/operations/pod_deleter_test.go b/providers/vic/operations/pod_deleter_test.go index d34a87811..1ac126e04 100644 --- a/providers/vic/operations/pod_deleter_test.go +++ b/providers/vic/operations/pod_deleter_test.go @@ -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)) } diff --git a/providers/vic/operations/pod_starter_test.go b/providers/vic/operations/pod_starter_test.go index 8073f4437..e18d63fe5 100644 --- a/providers/vic/operations/pod_starter_test.go +++ b/providers/vic/operations/pod_starter_test.go @@ -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. diff --git a/providers/vic/operations/pod_status_test.go b/providers/vic/operations/pod_status_test.go index 0b74eafc7..0894c0892 100644 --- a/providers/vic/operations/pod_status_test.go +++ b/providers/vic/operations/pod_status_test.go @@ -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 } } diff --git a/providers/vic/operations/pod_stopper_test.go b/providers/vic/operations/pod_stopper_test.go index 4ebe32cbb..1bca30f1f 100644 --- a/providers/vic/operations/pod_stopper_test.go +++ b/providers/vic/operations/pod_stopper_test.go @@ -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") -} \ No newline at end of file + assert.Check(t, is.Error(err, fakeErr.Error()), "Expected failed Commit error") +} diff --git a/providers/vic/utils/units_test.go b/providers/vic/utils/units_test.go index 938999d92..37f6f1e94 100644 --- a/providers/vic/utils/units_test.go +++ b/providers/vic/utils/units_test.go @@ -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") } diff --git a/vendor/github.com/stretchr/testify/require/doc.go b/vendor/github.com/stretchr/testify/require/doc.go deleted file mode 100644 index 169de3922..000000000 --- a/vendor/github.com/stretchr/testify/require/doc.go +++ /dev/null @@ -1,28 +0,0 @@ -// Package require implements the same assertions as the `assert` package but -// stops test execution when a test fails. -// -// Example Usage -// -// The following is a complete example using require in a standard test function: -// import ( -// "testing" -// "github.com/stretchr/testify/require" -// ) -// -// func TestSomething(t *testing.T) { -// -// var a string = "Hello" -// var b string = "Hello" -// -// require.Equal(t, a, b, "The two words should be the same.") -// -// } -// -// Assertions -// -// The `require` package have same global functions as in the `assert` package, -// but instead of returning a boolean result they call `t.FailNow()`. -// -// Every assertion function also takes an optional string message as the final argument, -// allowing custom error messages to be appended to the message the assertion method outputs. -package require diff --git a/vendor/github.com/stretchr/testify/require/forward_requirements.go b/vendor/github.com/stretchr/testify/require/forward_requirements.go deleted file mode 100644 index ac71d4058..000000000 --- a/vendor/github.com/stretchr/testify/require/forward_requirements.go +++ /dev/null @@ -1,16 +0,0 @@ -package require - -// Assertions provides assertion methods around the -// TestingT interface. -type Assertions struct { - t TestingT -} - -// New makes a new Assertions object for the specified TestingT. -func New(t TestingT) *Assertions { - return &Assertions{ - t: t, - } -} - -//go:generate go run ../_codegen/main.go -output-package=require -template=require_forward.go.tmpl -include-format-funcs diff --git a/vendor/github.com/stretchr/testify/require/require.go b/vendor/github.com/stretchr/testify/require/require.go deleted file mode 100644 index ac3c30878..000000000 --- a/vendor/github.com/stretchr/testify/require/require.go +++ /dev/null @@ -1,867 +0,0 @@ -/* -* CODE GENERATED AUTOMATICALLY WITH github.com/stretchr/testify/_codegen -* THIS FILE MUST NOT BE EDITED BY HAND - */ - -package require - -import ( - assert "github.com/stretchr/testify/assert" - http "net/http" - url "net/url" - time "time" -) - -// Condition uses a Comparison to assert a complex condition. -func Condition(t TestingT, comp assert.Comparison, msgAndArgs ...interface{}) { - if !assert.Condition(t, comp, msgAndArgs...) { - t.FailNow() - } -} - -// Conditionf uses a Comparison to assert a complex condition. -func Conditionf(t TestingT, comp assert.Comparison, msg string, args ...interface{}) { - if !assert.Conditionf(t, comp, msg, args...) { - t.FailNow() - } -} - -// Contains asserts that the specified string, list(array, slice...) or map contains the -// specified substring or element. -// -// assert.Contains(t, "Hello World", "World") -// assert.Contains(t, ["Hello", "World"], "World") -// assert.Contains(t, {"Hello": "World"}, "Hello") -func Contains(t TestingT, s interface{}, contains interface{}, msgAndArgs ...interface{}) { - if !assert.Contains(t, s, contains, msgAndArgs...) { - t.FailNow() - } -} - -// Containsf asserts that the specified string, list(array, slice...) or map contains the -// specified substring or element. -// -// assert.Containsf(t, "Hello World", "World", "error message %s", "formatted") -// assert.Containsf(t, ["Hello", "World"], "World", "error message %s", "formatted") -// assert.Containsf(t, {"Hello": "World"}, "Hello", "error message %s", "formatted") -func Containsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) { - if !assert.Containsf(t, s, contains, msg, args...) { - t.FailNow() - } -} - -// DirExists checks whether a directory exists in the given path. It also fails if the path is a file rather a directory or there is an error checking whether it exists. -func DirExists(t TestingT, path string, msgAndArgs ...interface{}) { - if !assert.DirExists(t, path, msgAndArgs...) { - t.FailNow() - } -} - -// DirExistsf checks whether a directory exists in the given path. It also fails if the path is a file rather a directory or there is an error checking whether it exists. -func DirExistsf(t TestingT, path string, msg string, args ...interface{}) { - if !assert.DirExistsf(t, path, msg, args...) { - t.FailNow() - } -} - -// ElementsMatch asserts that the specified listA(array, slice...) is equal to specified -// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements, -// the number of appearances of each of them in both lists should match. -// -// assert.ElementsMatch(t, [1, 3, 2, 3], [1, 3, 3, 2]) -func ElementsMatch(t TestingT, listA interface{}, listB interface{}, msgAndArgs ...interface{}) { - if !assert.ElementsMatch(t, listA, listB, msgAndArgs...) { - t.FailNow() - } -} - -// ElementsMatchf asserts that the specified listA(array, slice...) is equal to specified -// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements, -// the number of appearances of each of them in both lists should match. -// -// assert.ElementsMatchf(t, [1, 3, 2, 3], [1, 3, 3, 2], "error message %s", "formatted") -func ElementsMatchf(t TestingT, listA interface{}, listB interface{}, msg string, args ...interface{}) { - if !assert.ElementsMatchf(t, listA, listB, msg, args...) { - t.FailNow() - } -} - -// Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either -// a slice or a channel with len == 0. -// -// assert.Empty(t, obj) -func Empty(t TestingT, object interface{}, msgAndArgs ...interface{}) { - if !assert.Empty(t, object, msgAndArgs...) { - t.FailNow() - } -} - -// Emptyf asserts that the specified object is empty. I.e. nil, "", false, 0 or either -// a slice or a channel with len == 0. -// -// assert.Emptyf(t, obj, "error message %s", "formatted") -func Emptyf(t TestingT, object interface{}, msg string, args ...interface{}) { - if !assert.Emptyf(t, object, msg, args...) { - t.FailNow() - } -} - -// Equal asserts that two objects are equal. -// -// assert.Equal(t, 123, 123) -// -// Pointer variable equality is determined based on the equality of the -// referenced values (as opposed to the memory addresses). Function equality -// cannot be determined and will always fail. -func Equal(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { - if !assert.Equal(t, expected, actual, msgAndArgs...) { - t.FailNow() - } -} - -// EqualError asserts that a function returned an error (i.e. not `nil`) -// and that it is equal to the provided error. -// -// actualObj, err := SomeFunction() -// assert.EqualError(t, err, expectedErrorString) -func EqualError(t TestingT, theError error, errString string, msgAndArgs ...interface{}) { - if !assert.EqualError(t, theError, errString, msgAndArgs...) { - t.FailNow() - } -} - -// EqualErrorf asserts that a function returned an error (i.e. not `nil`) -// and that it is equal to the provided error. -// -// actualObj, err := SomeFunction() -// assert.EqualErrorf(t, err, expectedErrorString, "error message %s", "formatted") -func EqualErrorf(t TestingT, theError error, errString string, msg string, args ...interface{}) { - if !assert.EqualErrorf(t, theError, errString, msg, args...) { - t.FailNow() - } -} - -// EqualValues asserts that two objects are equal or convertable to the same types -// and equal. -// -// assert.EqualValues(t, uint32(123), int32(123)) -func EqualValues(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { - if !assert.EqualValues(t, expected, actual, msgAndArgs...) { - t.FailNow() - } -} - -// EqualValuesf asserts that two objects are equal or convertable to the same types -// and equal. -// -// assert.EqualValuesf(t, uint32(123, "error message %s", "formatted"), int32(123)) -func EqualValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) { - if !assert.EqualValuesf(t, expected, actual, msg, args...) { - t.FailNow() - } -} - -// Equalf asserts that two objects are equal. -// -// assert.Equalf(t, 123, 123, "error message %s", "formatted") -// -// Pointer variable equality is determined based on the equality of the -// referenced values (as opposed to the memory addresses). Function equality -// cannot be determined and will always fail. -func Equalf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) { - if !assert.Equalf(t, expected, actual, msg, args...) { - t.FailNow() - } -} - -// Error asserts that a function returned an error (i.e. not `nil`). -// -// actualObj, err := SomeFunction() -// if assert.Error(t, err) { -// assert.Equal(t, expectedError, err) -// } -func Error(t TestingT, err error, msgAndArgs ...interface{}) { - if !assert.Error(t, err, msgAndArgs...) { - t.FailNow() - } -} - -// Errorf asserts that a function returned an error (i.e. not `nil`). -// -// actualObj, err := SomeFunction() -// if assert.Errorf(t, err, "error message %s", "formatted") { -// assert.Equal(t, expectedErrorf, err) -// } -func Errorf(t TestingT, err error, msg string, args ...interface{}) { - if !assert.Errorf(t, err, msg, args...) { - t.FailNow() - } -} - -// Exactly asserts that two objects are equal in value and type. -// -// assert.Exactly(t, int32(123), int64(123)) -func Exactly(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { - if !assert.Exactly(t, expected, actual, msgAndArgs...) { - t.FailNow() - } -} - -// Exactlyf asserts that two objects are equal in value and type. -// -// assert.Exactlyf(t, int32(123, "error message %s", "formatted"), int64(123)) -func Exactlyf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) { - if !assert.Exactlyf(t, expected, actual, msg, args...) { - t.FailNow() - } -} - -// Fail reports a failure through -func Fail(t TestingT, failureMessage string, msgAndArgs ...interface{}) { - if !assert.Fail(t, failureMessage, msgAndArgs...) { - t.FailNow() - } -} - -// FailNow fails test -func FailNow(t TestingT, failureMessage string, msgAndArgs ...interface{}) { - if !assert.FailNow(t, failureMessage, msgAndArgs...) { - t.FailNow() - } -} - -// FailNowf fails test -func FailNowf(t TestingT, failureMessage string, msg string, args ...interface{}) { - if !assert.FailNowf(t, failureMessage, msg, args...) { - t.FailNow() - } -} - -// Failf reports a failure through -func Failf(t TestingT, failureMessage string, msg string, args ...interface{}) { - if !assert.Failf(t, failureMessage, msg, args...) { - t.FailNow() - } -} - -// False asserts that the specified value is false. -// -// assert.False(t, myBool) -func False(t TestingT, value bool, msgAndArgs ...interface{}) { - if !assert.False(t, value, msgAndArgs...) { - t.FailNow() - } -} - -// Falsef asserts that the specified value is false. -// -// assert.Falsef(t, myBool, "error message %s", "formatted") -func Falsef(t TestingT, value bool, msg string, args ...interface{}) { - if !assert.Falsef(t, value, msg, args...) { - t.FailNow() - } -} - -// FileExists checks whether a file exists in the given path. It also fails if the path points to a directory or there is an error when trying to check the file. -func FileExists(t TestingT, path string, msgAndArgs ...interface{}) { - if !assert.FileExists(t, path, msgAndArgs...) { - t.FailNow() - } -} - -// FileExistsf checks whether a file exists in the given path. It also fails if the path points to a directory or there is an error when trying to check the file. -func FileExistsf(t TestingT, path string, msg string, args ...interface{}) { - if !assert.FileExistsf(t, path, msg, args...) { - t.FailNow() - } -} - -// HTTPBodyContains asserts that a specified handler returns a -// body that contains a string. -// -// assert.HTTPBodyContains(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky") -// -// Returns whether the assertion was successful (true) or not (false). -func HTTPBodyContains(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) { - if !assert.HTTPBodyContains(t, handler, method, url, values, str, msgAndArgs...) { - t.FailNow() - } -} - -// HTTPBodyContainsf asserts that a specified handler returns a -// body that contains a string. -// -// assert.HTTPBodyContainsf(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted") -// -// Returns whether the assertion was successful (true) or not (false). -func HTTPBodyContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) { - if !assert.HTTPBodyContainsf(t, handler, method, url, values, str, msg, args...) { - t.FailNow() - } -} - -// HTTPBodyNotContains asserts that a specified handler returns a -// body that does not contain a string. -// -// assert.HTTPBodyNotContains(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky") -// -// Returns whether the assertion was successful (true) or not (false). -func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) { - if !assert.HTTPBodyNotContains(t, handler, method, url, values, str, msgAndArgs...) { - t.FailNow() - } -} - -// HTTPBodyNotContainsf asserts that a specified handler returns a -// body that does not contain a string. -// -// assert.HTTPBodyNotContainsf(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted") -// -// Returns whether the assertion was successful (true) or not (false). -func HTTPBodyNotContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) { - if !assert.HTTPBodyNotContainsf(t, handler, method, url, values, str, msg, args...) { - t.FailNow() - } -} - -// HTTPError asserts that a specified handler returns an error status code. -// -// assert.HTTPError(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}} -// -// Returns whether the assertion was successful (true) or not (false). -func HTTPError(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) { - if !assert.HTTPError(t, handler, method, url, values, msgAndArgs...) { - t.FailNow() - } -} - -// HTTPErrorf asserts that a specified handler returns an error status code. -// -// assert.HTTPErrorf(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}} -// -// Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false). -func HTTPErrorf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) { - if !assert.HTTPErrorf(t, handler, method, url, values, msg, args...) { - t.FailNow() - } -} - -// HTTPRedirect asserts that a specified handler returns a redirect status code. -// -// assert.HTTPRedirect(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}} -// -// Returns whether the assertion was successful (true) or not (false). -func HTTPRedirect(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) { - if !assert.HTTPRedirect(t, handler, method, url, values, msgAndArgs...) { - t.FailNow() - } -} - -// HTTPRedirectf asserts that a specified handler returns a redirect status code. -// -// assert.HTTPRedirectf(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}} -// -// Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false). -func HTTPRedirectf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) { - if !assert.HTTPRedirectf(t, handler, method, url, values, msg, args...) { - t.FailNow() - } -} - -// HTTPSuccess asserts that a specified handler returns a success status code. -// -// assert.HTTPSuccess(t, myHandler, "POST", "http://www.google.com", nil) -// -// Returns whether the assertion was successful (true) or not (false). -func HTTPSuccess(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) { - if !assert.HTTPSuccess(t, handler, method, url, values, msgAndArgs...) { - t.FailNow() - } -} - -// HTTPSuccessf asserts that a specified handler returns a success status code. -// -// assert.HTTPSuccessf(t, myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted") -// -// Returns whether the assertion was successful (true) or not (false). -func HTTPSuccessf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) { - if !assert.HTTPSuccessf(t, handler, method, url, values, msg, args...) { - t.FailNow() - } -} - -// Implements asserts that an object is implemented by the specified interface. -// -// assert.Implements(t, (*MyInterface)(nil), new(MyObject)) -func Implements(t TestingT, interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) { - if !assert.Implements(t, interfaceObject, object, msgAndArgs...) { - t.FailNow() - } -} - -// Implementsf asserts that an object is implemented by the specified interface. -// -// assert.Implementsf(t, (*MyInterface, "error message %s", "formatted")(nil), new(MyObject)) -func Implementsf(t TestingT, interfaceObject interface{}, object interface{}, msg string, args ...interface{}) { - if !assert.Implementsf(t, interfaceObject, object, msg, args...) { - t.FailNow() - } -} - -// InDelta asserts that the two numerals are within delta of each other. -// -// assert.InDelta(t, math.Pi, (22 / 7.0), 0.01) -func InDelta(t TestingT, expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) { - if !assert.InDelta(t, expected, actual, delta, msgAndArgs...) { - t.FailNow() - } -} - -// InDeltaMapValues is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys. -func InDeltaMapValues(t TestingT, expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) { - if !assert.InDeltaMapValues(t, expected, actual, delta, msgAndArgs...) { - t.FailNow() - } -} - -// InDeltaMapValuesf is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys. -func InDeltaMapValuesf(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) { - if !assert.InDeltaMapValuesf(t, expected, actual, delta, msg, args...) { - t.FailNow() - } -} - -// InDeltaSlice is the same as InDelta, except it compares two slices. -func InDeltaSlice(t TestingT, expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) { - if !assert.InDeltaSlice(t, expected, actual, delta, msgAndArgs...) { - t.FailNow() - } -} - -// InDeltaSlicef is the same as InDelta, except it compares two slices. -func InDeltaSlicef(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) { - if !assert.InDeltaSlicef(t, expected, actual, delta, msg, args...) { - t.FailNow() - } -} - -// InDeltaf asserts that the two numerals are within delta of each other. -// -// assert.InDeltaf(t, math.Pi, (22 / 7.0, "error message %s", "formatted"), 0.01) -func InDeltaf(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) { - if !assert.InDeltaf(t, expected, actual, delta, msg, args...) { - t.FailNow() - } -} - -// InEpsilon asserts that expected and actual have a relative error less than epsilon -func InEpsilon(t TestingT, expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) { - if !assert.InEpsilon(t, expected, actual, epsilon, msgAndArgs...) { - t.FailNow() - } -} - -// InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices. -func InEpsilonSlice(t TestingT, expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) { - if !assert.InEpsilonSlice(t, expected, actual, epsilon, msgAndArgs...) { - t.FailNow() - } -} - -// InEpsilonSlicef is the same as InEpsilon, except it compares each value from two slices. -func InEpsilonSlicef(t TestingT, expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) { - if !assert.InEpsilonSlicef(t, expected, actual, epsilon, msg, args...) { - t.FailNow() - } -} - -// InEpsilonf asserts that expected and actual have a relative error less than epsilon -func InEpsilonf(t TestingT, expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) { - if !assert.InEpsilonf(t, expected, actual, epsilon, msg, args...) { - t.FailNow() - } -} - -// IsType asserts that the specified objects are of the same type. -func IsType(t TestingT, expectedType interface{}, object interface{}, msgAndArgs ...interface{}) { - if !assert.IsType(t, expectedType, object, msgAndArgs...) { - t.FailNow() - } -} - -// IsTypef asserts that the specified objects are of the same type. -func IsTypef(t TestingT, expectedType interface{}, object interface{}, msg string, args ...interface{}) { - if !assert.IsTypef(t, expectedType, object, msg, args...) { - t.FailNow() - } -} - -// JSONEq asserts that two JSON strings are equivalent. -// -// assert.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) -func JSONEq(t TestingT, expected string, actual string, msgAndArgs ...interface{}) { - if !assert.JSONEq(t, expected, actual, msgAndArgs...) { - t.FailNow() - } -} - -// JSONEqf asserts that two JSON strings are equivalent. -// -// assert.JSONEqf(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted") -func JSONEqf(t TestingT, expected string, actual string, msg string, args ...interface{}) { - if !assert.JSONEqf(t, expected, actual, msg, args...) { - t.FailNow() - } -} - -// Len asserts that the specified object has specific length. -// Len also fails if the object has a type that len() not accept. -// -// assert.Len(t, mySlice, 3) -func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{}) { - if !assert.Len(t, object, length, msgAndArgs...) { - t.FailNow() - } -} - -// Lenf asserts that the specified object has specific length. -// Lenf also fails if the object has a type that len() not accept. -// -// assert.Lenf(t, mySlice, 3, "error message %s", "formatted") -func Lenf(t TestingT, object interface{}, length int, msg string, args ...interface{}) { - if !assert.Lenf(t, object, length, msg, args...) { - t.FailNow() - } -} - -// Nil asserts that the specified object is nil. -// -// assert.Nil(t, err) -func Nil(t TestingT, object interface{}, msgAndArgs ...interface{}) { - if !assert.Nil(t, object, msgAndArgs...) { - t.FailNow() - } -} - -// Nilf asserts that the specified object is nil. -// -// assert.Nilf(t, err, "error message %s", "formatted") -func Nilf(t TestingT, object interface{}, msg string, args ...interface{}) { - if !assert.Nilf(t, object, msg, args...) { - t.FailNow() - } -} - -// NoError asserts that a function returned no error (i.e. `nil`). -// -// actualObj, err := SomeFunction() -// if assert.NoError(t, err) { -// assert.Equal(t, expectedObj, actualObj) -// } -func NoError(t TestingT, err error, msgAndArgs ...interface{}) { - if !assert.NoError(t, err, msgAndArgs...) { - t.FailNow() - } -} - -// NoErrorf asserts that a function returned no error (i.e. `nil`). -// -// actualObj, err := SomeFunction() -// if assert.NoErrorf(t, err, "error message %s", "formatted") { -// assert.Equal(t, expectedObj, actualObj) -// } -func NoErrorf(t TestingT, err error, msg string, args ...interface{}) { - if !assert.NoErrorf(t, err, msg, args...) { - t.FailNow() - } -} - -// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the -// specified substring or element. -// -// assert.NotContains(t, "Hello World", "Earth") -// assert.NotContains(t, ["Hello", "World"], "Earth") -// assert.NotContains(t, {"Hello": "World"}, "Earth") -func NotContains(t TestingT, s interface{}, contains interface{}, msgAndArgs ...interface{}) { - if !assert.NotContains(t, s, contains, msgAndArgs...) { - t.FailNow() - } -} - -// NotContainsf asserts that the specified string, list(array, slice...) or map does NOT contain the -// specified substring or element. -// -// assert.NotContainsf(t, "Hello World", "Earth", "error message %s", "formatted") -// assert.NotContainsf(t, ["Hello", "World"], "Earth", "error message %s", "formatted") -// assert.NotContainsf(t, {"Hello": "World"}, "Earth", "error message %s", "formatted") -func NotContainsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) { - if !assert.NotContainsf(t, s, contains, msg, args...) { - t.FailNow() - } -} - -// NotEmpty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either -// a slice or a channel with len == 0. -// -// if assert.NotEmpty(t, obj) { -// assert.Equal(t, "two", obj[1]) -// } -func NotEmpty(t TestingT, object interface{}, msgAndArgs ...interface{}) { - if !assert.NotEmpty(t, object, msgAndArgs...) { - t.FailNow() - } -} - -// NotEmptyf asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either -// a slice or a channel with len == 0. -// -// if assert.NotEmptyf(t, obj, "error message %s", "formatted") { -// assert.Equal(t, "two", obj[1]) -// } -func NotEmptyf(t TestingT, object interface{}, msg string, args ...interface{}) { - if !assert.NotEmptyf(t, object, msg, args...) { - t.FailNow() - } -} - -// NotEqual asserts that the specified values are NOT equal. -// -// assert.NotEqual(t, obj1, obj2) -// -// Pointer variable equality is determined based on the equality of the -// referenced values (as opposed to the memory addresses). -func NotEqual(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { - if !assert.NotEqual(t, expected, actual, msgAndArgs...) { - t.FailNow() - } -} - -// NotEqualf asserts that the specified values are NOT equal. -// -// assert.NotEqualf(t, obj1, obj2, "error message %s", "formatted") -// -// Pointer variable equality is determined based on the equality of the -// referenced values (as opposed to the memory addresses). -func NotEqualf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) { - if !assert.NotEqualf(t, expected, actual, msg, args...) { - t.FailNow() - } -} - -// NotNil asserts that the specified object is not nil. -// -// assert.NotNil(t, err) -func NotNil(t TestingT, object interface{}, msgAndArgs ...interface{}) { - if !assert.NotNil(t, object, msgAndArgs...) { - t.FailNow() - } -} - -// NotNilf asserts that the specified object is not nil. -// -// assert.NotNilf(t, err, "error message %s", "formatted") -func NotNilf(t TestingT, object interface{}, msg string, args ...interface{}) { - if !assert.NotNilf(t, object, msg, args...) { - t.FailNow() - } -} - -// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic. -// -// assert.NotPanics(t, func(){ RemainCalm() }) -func NotPanics(t TestingT, f assert.PanicTestFunc, msgAndArgs ...interface{}) { - if !assert.NotPanics(t, f, msgAndArgs...) { - t.FailNow() - } -} - -// NotPanicsf asserts that the code inside the specified PanicTestFunc does NOT panic. -// -// assert.NotPanicsf(t, func(){ RemainCalm() }, "error message %s", "formatted") -func NotPanicsf(t TestingT, f assert.PanicTestFunc, msg string, args ...interface{}) { - if !assert.NotPanicsf(t, f, msg, args...) { - t.FailNow() - } -} - -// NotRegexp asserts that a specified regexp does not match a string. -// -// assert.NotRegexp(t, regexp.MustCompile("starts"), "it's starting") -// assert.NotRegexp(t, "^start", "it's not starting") -func NotRegexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) { - if !assert.NotRegexp(t, rx, str, msgAndArgs...) { - t.FailNow() - } -} - -// NotRegexpf asserts that a specified regexp does not match a string. -// -// assert.NotRegexpf(t, regexp.MustCompile("starts", "error message %s", "formatted"), "it's starting") -// assert.NotRegexpf(t, "^start", "it's not starting", "error message %s", "formatted") -func NotRegexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) { - if !assert.NotRegexpf(t, rx, str, msg, args...) { - t.FailNow() - } -} - -// NotSubset asserts that the specified list(array, slice...) contains not all -// elements given in the specified subset(array, slice...). -// -// assert.NotSubset(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]") -func NotSubset(t TestingT, list interface{}, subset interface{}, msgAndArgs ...interface{}) { - if !assert.NotSubset(t, list, subset, msgAndArgs...) { - t.FailNow() - } -} - -// NotSubsetf asserts that the specified list(array, slice...) contains not all -// elements given in the specified subset(array, slice...). -// -// assert.NotSubsetf(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted") -func NotSubsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) { - if !assert.NotSubsetf(t, list, subset, msg, args...) { - t.FailNow() - } -} - -// NotZero asserts that i is not the zero value for its type. -func NotZero(t TestingT, i interface{}, msgAndArgs ...interface{}) { - if !assert.NotZero(t, i, msgAndArgs...) { - t.FailNow() - } -} - -// NotZerof asserts that i is not the zero value for its type. -func NotZerof(t TestingT, i interface{}, msg string, args ...interface{}) { - if !assert.NotZerof(t, i, msg, args...) { - t.FailNow() - } -} - -// Panics asserts that the code inside the specified PanicTestFunc panics. -// -// assert.Panics(t, func(){ GoCrazy() }) -func Panics(t TestingT, f assert.PanicTestFunc, msgAndArgs ...interface{}) { - if !assert.Panics(t, f, msgAndArgs...) { - t.FailNow() - } -} - -// PanicsWithValue asserts that the code inside the specified PanicTestFunc panics, and that -// the recovered panic value equals the expected panic value. -// -// assert.PanicsWithValue(t, "crazy error", func(){ GoCrazy() }) -func PanicsWithValue(t TestingT, expected interface{}, f assert.PanicTestFunc, msgAndArgs ...interface{}) { - if !assert.PanicsWithValue(t, expected, f, msgAndArgs...) { - t.FailNow() - } -} - -// PanicsWithValuef asserts that the code inside the specified PanicTestFunc panics, and that -// the recovered panic value equals the expected panic value. -// -// assert.PanicsWithValuef(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted") -func PanicsWithValuef(t TestingT, expected interface{}, f assert.PanicTestFunc, msg string, args ...interface{}) { - if !assert.PanicsWithValuef(t, expected, f, msg, args...) { - t.FailNow() - } -} - -// Panicsf asserts that the code inside the specified PanicTestFunc panics. -// -// assert.Panicsf(t, func(){ GoCrazy() }, "error message %s", "formatted") -func Panicsf(t TestingT, f assert.PanicTestFunc, msg string, args ...interface{}) { - if !assert.Panicsf(t, f, msg, args...) { - t.FailNow() - } -} - -// Regexp asserts that a specified regexp matches a string. -// -// assert.Regexp(t, regexp.MustCompile("start"), "it's starting") -// assert.Regexp(t, "start...$", "it's not starting") -func Regexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) { - if !assert.Regexp(t, rx, str, msgAndArgs...) { - t.FailNow() - } -} - -// Regexpf asserts that a specified regexp matches a string. -// -// assert.Regexpf(t, regexp.MustCompile("start", "error message %s", "formatted"), "it's starting") -// assert.Regexpf(t, "start...$", "it's not starting", "error message %s", "formatted") -func Regexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) { - if !assert.Regexpf(t, rx, str, msg, args...) { - t.FailNow() - } -} - -// Subset asserts that the specified list(array, slice...) contains all -// elements given in the specified subset(array, slice...). -// -// assert.Subset(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]") -func Subset(t TestingT, list interface{}, subset interface{}, msgAndArgs ...interface{}) { - if !assert.Subset(t, list, subset, msgAndArgs...) { - t.FailNow() - } -} - -// Subsetf asserts that the specified list(array, slice...) contains all -// elements given in the specified subset(array, slice...). -// -// assert.Subsetf(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted") -func Subsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) { - if !assert.Subsetf(t, list, subset, msg, args...) { - t.FailNow() - } -} - -// True asserts that the specified value is true. -// -// assert.True(t, myBool) -func True(t TestingT, value bool, msgAndArgs ...interface{}) { - if !assert.True(t, value, msgAndArgs...) { - t.FailNow() - } -} - -// Truef asserts that the specified value is true. -// -// assert.Truef(t, myBool, "error message %s", "formatted") -func Truef(t TestingT, value bool, msg string, args ...interface{}) { - if !assert.Truef(t, value, msg, args...) { - t.FailNow() - } -} - -// WithinDuration asserts that the two times are within duration delta of each other. -// -// assert.WithinDuration(t, time.Now(), time.Now(), 10*time.Second) -func WithinDuration(t TestingT, expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) { - if !assert.WithinDuration(t, expected, actual, delta, msgAndArgs...) { - t.FailNow() - } -} - -// WithinDurationf asserts that the two times are within duration delta of each other. -// -// assert.WithinDurationf(t, time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted") -func WithinDurationf(t TestingT, expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) { - if !assert.WithinDurationf(t, expected, actual, delta, msg, args...) { - t.FailNow() - } -} - -// Zero asserts that i is the zero value for its type. -func Zero(t TestingT, i interface{}, msgAndArgs ...interface{}) { - if !assert.Zero(t, i, msgAndArgs...) { - t.FailNow() - } -} - -// Zerof asserts that i is the zero value for its type. -func Zerof(t TestingT, i interface{}, msg string, args ...interface{}) { - if !assert.Zerof(t, i, msg, args...) { - t.FailNow() - } -} diff --git a/vendor/github.com/stretchr/testify/require/require_forward.go b/vendor/github.com/stretchr/testify/require/require_forward.go deleted file mode 100644 index 299ceb95a..000000000 --- a/vendor/github.com/stretchr/testify/require/require_forward.go +++ /dev/null @@ -1,687 +0,0 @@ -/* -* CODE GENERATED AUTOMATICALLY WITH github.com/stretchr/testify/_codegen -* THIS FILE MUST NOT BE EDITED BY HAND - */ - -package require - -import ( - assert "github.com/stretchr/testify/assert" - http "net/http" - url "net/url" - time "time" -) - -// Condition uses a Comparison to assert a complex condition. -func (a *Assertions) Condition(comp assert.Comparison, msgAndArgs ...interface{}) { - Condition(a.t, comp, msgAndArgs...) -} - -// Conditionf uses a Comparison to assert a complex condition. -func (a *Assertions) Conditionf(comp assert.Comparison, msg string, args ...interface{}) { - Conditionf(a.t, comp, msg, args...) -} - -// Contains asserts that the specified string, list(array, slice...) or map contains the -// specified substring or element. -// -// a.Contains("Hello World", "World") -// a.Contains(["Hello", "World"], "World") -// a.Contains({"Hello": "World"}, "Hello") -func (a *Assertions) Contains(s interface{}, contains interface{}, msgAndArgs ...interface{}) { - Contains(a.t, s, contains, msgAndArgs...) -} - -// Containsf asserts that the specified string, list(array, slice...) or map contains the -// specified substring or element. -// -// a.Containsf("Hello World", "World", "error message %s", "formatted") -// a.Containsf(["Hello", "World"], "World", "error message %s", "formatted") -// a.Containsf({"Hello": "World"}, "Hello", "error message %s", "formatted") -func (a *Assertions) Containsf(s interface{}, contains interface{}, msg string, args ...interface{}) { - Containsf(a.t, s, contains, msg, args...) -} - -// DirExists checks whether a directory exists in the given path. It also fails if the path is a file rather a directory or there is an error checking whether it exists. -func (a *Assertions) DirExists(path string, msgAndArgs ...interface{}) { - DirExists(a.t, path, msgAndArgs...) -} - -// DirExistsf checks whether a directory exists in the given path. It also fails if the path is a file rather a directory or there is an error checking whether it exists. -func (a *Assertions) DirExistsf(path string, msg string, args ...interface{}) { - DirExistsf(a.t, path, msg, args...) -} - -// ElementsMatch asserts that the specified listA(array, slice...) is equal to specified -// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements, -// the number of appearances of each of them in both lists should match. -// -// a.ElementsMatch([1, 3, 2, 3], [1, 3, 3, 2]) -func (a *Assertions) ElementsMatch(listA interface{}, listB interface{}, msgAndArgs ...interface{}) { - ElementsMatch(a.t, listA, listB, msgAndArgs...) -} - -// ElementsMatchf asserts that the specified listA(array, slice...) is equal to specified -// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements, -// the number of appearances of each of them in both lists should match. -// -// a.ElementsMatchf([1, 3, 2, 3], [1, 3, 3, 2], "error message %s", "formatted") -func (a *Assertions) ElementsMatchf(listA interface{}, listB interface{}, msg string, args ...interface{}) { - ElementsMatchf(a.t, listA, listB, msg, args...) -} - -// Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either -// a slice or a channel with len == 0. -// -// a.Empty(obj) -func (a *Assertions) Empty(object interface{}, msgAndArgs ...interface{}) { - Empty(a.t, object, msgAndArgs...) -} - -// Emptyf asserts that the specified object is empty. I.e. nil, "", false, 0 or either -// a slice or a channel with len == 0. -// -// a.Emptyf(obj, "error message %s", "formatted") -func (a *Assertions) Emptyf(object interface{}, msg string, args ...interface{}) { - Emptyf(a.t, object, msg, args...) -} - -// Equal asserts that two objects are equal. -// -// a.Equal(123, 123) -// -// Pointer variable equality is determined based on the equality of the -// referenced values (as opposed to the memory addresses). Function equality -// cannot be determined and will always fail. -func (a *Assertions) Equal(expected interface{}, actual interface{}, msgAndArgs ...interface{}) { - Equal(a.t, expected, actual, msgAndArgs...) -} - -// EqualError asserts that a function returned an error (i.e. not `nil`) -// and that it is equal to the provided error. -// -// actualObj, err := SomeFunction() -// a.EqualError(err, expectedErrorString) -func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ...interface{}) { - EqualError(a.t, theError, errString, msgAndArgs...) -} - -// EqualErrorf asserts that a function returned an error (i.e. not `nil`) -// and that it is equal to the provided error. -// -// actualObj, err := SomeFunction() -// a.EqualErrorf(err, expectedErrorString, "error message %s", "formatted") -func (a *Assertions) EqualErrorf(theError error, errString string, msg string, args ...interface{}) { - EqualErrorf(a.t, theError, errString, msg, args...) -} - -// EqualValues asserts that two objects are equal or convertable to the same types -// and equal. -// -// a.EqualValues(uint32(123), int32(123)) -func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) { - EqualValues(a.t, expected, actual, msgAndArgs...) -} - -// EqualValuesf asserts that two objects are equal or convertable to the same types -// and equal. -// -// a.EqualValuesf(uint32(123, "error message %s", "formatted"), int32(123)) -func (a *Assertions) EqualValuesf(expected interface{}, actual interface{}, msg string, args ...interface{}) { - EqualValuesf(a.t, expected, actual, msg, args...) -} - -// Equalf asserts that two objects are equal. -// -// a.Equalf(123, 123, "error message %s", "formatted") -// -// Pointer variable equality is determined based on the equality of the -// referenced values (as opposed to the memory addresses). Function equality -// cannot be determined and will always fail. -func (a *Assertions) Equalf(expected interface{}, actual interface{}, msg string, args ...interface{}) { - Equalf(a.t, expected, actual, msg, args...) -} - -// Error asserts that a function returned an error (i.e. not `nil`). -// -// actualObj, err := SomeFunction() -// if a.Error(err) { -// assert.Equal(t, expectedError, err) -// } -func (a *Assertions) Error(err error, msgAndArgs ...interface{}) { - Error(a.t, err, msgAndArgs...) -} - -// Errorf asserts that a function returned an error (i.e. not `nil`). -// -// actualObj, err := SomeFunction() -// if a.Errorf(err, "error message %s", "formatted") { -// assert.Equal(t, expectedErrorf, err) -// } -func (a *Assertions) Errorf(err error, msg string, args ...interface{}) { - Errorf(a.t, err, msg, args...) -} - -// Exactly asserts that two objects are equal in value and type. -// -// a.Exactly(int32(123), int64(123)) -func (a *Assertions) Exactly(expected interface{}, actual interface{}, msgAndArgs ...interface{}) { - Exactly(a.t, expected, actual, msgAndArgs...) -} - -// Exactlyf asserts that two objects are equal in value and type. -// -// a.Exactlyf(int32(123, "error message %s", "formatted"), int64(123)) -func (a *Assertions) Exactlyf(expected interface{}, actual interface{}, msg string, args ...interface{}) { - Exactlyf(a.t, expected, actual, msg, args...) -} - -// Fail reports a failure through -func (a *Assertions) Fail(failureMessage string, msgAndArgs ...interface{}) { - Fail(a.t, failureMessage, msgAndArgs...) -} - -// FailNow fails test -func (a *Assertions) FailNow(failureMessage string, msgAndArgs ...interface{}) { - FailNow(a.t, failureMessage, msgAndArgs...) -} - -// FailNowf fails test -func (a *Assertions) FailNowf(failureMessage string, msg string, args ...interface{}) { - FailNowf(a.t, failureMessage, msg, args...) -} - -// Failf reports a failure through -func (a *Assertions) Failf(failureMessage string, msg string, args ...interface{}) { - Failf(a.t, failureMessage, msg, args...) -} - -// False asserts that the specified value is false. -// -// a.False(myBool) -func (a *Assertions) False(value bool, msgAndArgs ...interface{}) { - False(a.t, value, msgAndArgs...) -} - -// Falsef asserts that the specified value is false. -// -// a.Falsef(myBool, "error message %s", "formatted") -func (a *Assertions) Falsef(value bool, msg string, args ...interface{}) { - Falsef(a.t, value, msg, args...) -} - -// FileExists checks whether a file exists in the given path. It also fails if the path points to a directory or there is an error when trying to check the file. -func (a *Assertions) FileExists(path string, msgAndArgs ...interface{}) { - FileExists(a.t, path, msgAndArgs...) -} - -// FileExistsf checks whether a file exists in the given path. It also fails if the path points to a directory or there is an error when trying to check the file. -func (a *Assertions) FileExistsf(path string, msg string, args ...interface{}) { - FileExistsf(a.t, path, msg, args...) -} - -// HTTPBodyContains asserts that a specified handler returns a -// body that contains a string. -// -// a.HTTPBodyContains(myHandler, "www.google.com", nil, "I'm Feeling Lucky") -// -// Returns whether the assertion was successful (true) or not (false). -func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) { - HTTPBodyContains(a.t, handler, method, url, values, str, msgAndArgs...) -} - -// HTTPBodyContainsf asserts that a specified handler returns a -// body that contains a string. -// -// a.HTTPBodyContainsf(myHandler, "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted") -// -// Returns whether the assertion was successful (true) or not (false). -func (a *Assertions) HTTPBodyContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) { - HTTPBodyContainsf(a.t, handler, method, url, values, str, msg, args...) -} - -// HTTPBodyNotContains asserts that a specified handler returns a -// body that does not contain a string. -// -// a.HTTPBodyNotContains(myHandler, "www.google.com", nil, "I'm Feeling Lucky") -// -// Returns whether the assertion was successful (true) or not (false). -func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) { - HTTPBodyNotContains(a.t, handler, method, url, values, str, msgAndArgs...) -} - -// HTTPBodyNotContainsf asserts that a specified handler returns a -// body that does not contain a string. -// -// a.HTTPBodyNotContainsf(myHandler, "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted") -// -// Returns whether the assertion was successful (true) or not (false). -func (a *Assertions) HTTPBodyNotContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) { - HTTPBodyNotContainsf(a.t, handler, method, url, values, str, msg, args...) -} - -// HTTPError asserts that a specified handler returns an error status code. -// -// a.HTTPError(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}} -// -// Returns whether the assertion was successful (true) or not (false). -func (a *Assertions) HTTPError(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) { - HTTPError(a.t, handler, method, url, values, msgAndArgs...) -} - -// HTTPErrorf asserts that a specified handler returns an error status code. -// -// a.HTTPErrorf(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}} -// -// Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false). -func (a *Assertions) HTTPErrorf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) { - HTTPErrorf(a.t, handler, method, url, values, msg, args...) -} - -// HTTPRedirect asserts that a specified handler returns a redirect status code. -// -// a.HTTPRedirect(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}} -// -// Returns whether the assertion was successful (true) or not (false). -func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) { - HTTPRedirect(a.t, handler, method, url, values, msgAndArgs...) -} - -// HTTPRedirectf asserts that a specified handler returns a redirect status code. -// -// a.HTTPRedirectf(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}} -// -// Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false). -func (a *Assertions) HTTPRedirectf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) { - HTTPRedirectf(a.t, handler, method, url, values, msg, args...) -} - -// HTTPSuccess asserts that a specified handler returns a success status code. -// -// a.HTTPSuccess(myHandler, "POST", "http://www.google.com", nil) -// -// Returns whether the assertion was successful (true) or not (false). -func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) { - HTTPSuccess(a.t, handler, method, url, values, msgAndArgs...) -} - -// HTTPSuccessf asserts that a specified handler returns a success status code. -// -// a.HTTPSuccessf(myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted") -// -// Returns whether the assertion was successful (true) or not (false). -func (a *Assertions) HTTPSuccessf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) { - HTTPSuccessf(a.t, handler, method, url, values, msg, args...) -} - -// Implements asserts that an object is implemented by the specified interface. -// -// a.Implements((*MyInterface)(nil), new(MyObject)) -func (a *Assertions) Implements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) { - Implements(a.t, interfaceObject, object, msgAndArgs...) -} - -// Implementsf asserts that an object is implemented by the specified interface. -// -// a.Implementsf((*MyInterface, "error message %s", "formatted")(nil), new(MyObject)) -func (a *Assertions) Implementsf(interfaceObject interface{}, object interface{}, msg string, args ...interface{}) { - Implementsf(a.t, interfaceObject, object, msg, args...) -} - -// InDelta asserts that the two numerals are within delta of each other. -// -// a.InDelta(math.Pi, (22 / 7.0), 0.01) -func (a *Assertions) InDelta(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) { - InDelta(a.t, expected, actual, delta, msgAndArgs...) -} - -// InDeltaMapValues is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys. -func (a *Assertions) InDeltaMapValues(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) { - InDeltaMapValues(a.t, expected, actual, delta, msgAndArgs...) -} - -// InDeltaMapValuesf is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys. -func (a *Assertions) InDeltaMapValuesf(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) { - InDeltaMapValuesf(a.t, expected, actual, delta, msg, args...) -} - -// InDeltaSlice is the same as InDelta, except it compares two slices. -func (a *Assertions) InDeltaSlice(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) { - InDeltaSlice(a.t, expected, actual, delta, msgAndArgs...) -} - -// InDeltaSlicef is the same as InDelta, except it compares two slices. -func (a *Assertions) InDeltaSlicef(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) { - InDeltaSlicef(a.t, expected, actual, delta, msg, args...) -} - -// InDeltaf asserts that the two numerals are within delta of each other. -// -// a.InDeltaf(math.Pi, (22 / 7.0, "error message %s", "formatted"), 0.01) -func (a *Assertions) InDeltaf(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) { - InDeltaf(a.t, expected, actual, delta, msg, args...) -} - -// InEpsilon asserts that expected and actual have a relative error less than epsilon -func (a *Assertions) InEpsilon(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) { - InEpsilon(a.t, expected, actual, epsilon, msgAndArgs...) -} - -// InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices. -func (a *Assertions) InEpsilonSlice(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) { - InEpsilonSlice(a.t, expected, actual, epsilon, msgAndArgs...) -} - -// InEpsilonSlicef is the same as InEpsilon, except it compares each value from two slices. -func (a *Assertions) InEpsilonSlicef(expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) { - InEpsilonSlicef(a.t, expected, actual, epsilon, msg, args...) -} - -// InEpsilonf asserts that expected and actual have a relative error less than epsilon -func (a *Assertions) InEpsilonf(expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) { - InEpsilonf(a.t, expected, actual, epsilon, msg, args...) -} - -// IsType asserts that the specified objects are of the same type. -func (a *Assertions) IsType(expectedType interface{}, object interface{}, msgAndArgs ...interface{}) { - IsType(a.t, expectedType, object, msgAndArgs...) -} - -// IsTypef asserts that the specified objects are of the same type. -func (a *Assertions) IsTypef(expectedType interface{}, object interface{}, msg string, args ...interface{}) { - IsTypef(a.t, expectedType, object, msg, args...) -} - -// JSONEq asserts that two JSON strings are equivalent. -// -// a.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) -func (a *Assertions) JSONEq(expected string, actual string, msgAndArgs ...interface{}) { - JSONEq(a.t, expected, actual, msgAndArgs...) -} - -// JSONEqf asserts that two JSON strings are equivalent. -// -// a.JSONEqf(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted") -func (a *Assertions) JSONEqf(expected string, actual string, msg string, args ...interface{}) { - JSONEqf(a.t, expected, actual, msg, args...) -} - -// Len asserts that the specified object has specific length. -// Len also fails if the object has a type that len() not accept. -// -// a.Len(mySlice, 3) -func (a *Assertions) Len(object interface{}, length int, msgAndArgs ...interface{}) { - Len(a.t, object, length, msgAndArgs...) -} - -// Lenf asserts that the specified object has specific length. -// Lenf also fails if the object has a type that len() not accept. -// -// a.Lenf(mySlice, 3, "error message %s", "formatted") -func (a *Assertions) Lenf(object interface{}, length int, msg string, args ...interface{}) { - Lenf(a.t, object, length, msg, args...) -} - -// Nil asserts that the specified object is nil. -// -// a.Nil(err) -func (a *Assertions) Nil(object interface{}, msgAndArgs ...interface{}) { - Nil(a.t, object, msgAndArgs...) -} - -// Nilf asserts that the specified object is nil. -// -// a.Nilf(err, "error message %s", "formatted") -func (a *Assertions) Nilf(object interface{}, msg string, args ...interface{}) { - Nilf(a.t, object, msg, args...) -} - -// NoError asserts that a function returned no error (i.e. `nil`). -// -// actualObj, err := SomeFunction() -// if a.NoError(err) { -// assert.Equal(t, expectedObj, actualObj) -// } -func (a *Assertions) NoError(err error, msgAndArgs ...interface{}) { - NoError(a.t, err, msgAndArgs...) -} - -// NoErrorf asserts that a function returned no error (i.e. `nil`). -// -// actualObj, err := SomeFunction() -// if a.NoErrorf(err, "error message %s", "formatted") { -// assert.Equal(t, expectedObj, actualObj) -// } -func (a *Assertions) NoErrorf(err error, msg string, args ...interface{}) { - NoErrorf(a.t, err, msg, args...) -} - -// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the -// specified substring or element. -// -// a.NotContains("Hello World", "Earth") -// a.NotContains(["Hello", "World"], "Earth") -// a.NotContains({"Hello": "World"}, "Earth") -func (a *Assertions) NotContains(s interface{}, contains interface{}, msgAndArgs ...interface{}) { - NotContains(a.t, s, contains, msgAndArgs...) -} - -// NotContainsf asserts that the specified string, list(array, slice...) or map does NOT contain the -// specified substring or element. -// -// a.NotContainsf("Hello World", "Earth", "error message %s", "formatted") -// a.NotContainsf(["Hello", "World"], "Earth", "error message %s", "formatted") -// a.NotContainsf({"Hello": "World"}, "Earth", "error message %s", "formatted") -func (a *Assertions) NotContainsf(s interface{}, contains interface{}, msg string, args ...interface{}) { - NotContainsf(a.t, s, contains, msg, args...) -} - -// NotEmpty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either -// a slice or a channel with len == 0. -// -// if a.NotEmpty(obj) { -// assert.Equal(t, "two", obj[1]) -// } -func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{}) { - NotEmpty(a.t, object, msgAndArgs...) -} - -// NotEmptyf asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either -// a slice or a channel with len == 0. -// -// if a.NotEmptyf(obj, "error message %s", "formatted") { -// assert.Equal(t, "two", obj[1]) -// } -func (a *Assertions) NotEmptyf(object interface{}, msg string, args ...interface{}) { - NotEmptyf(a.t, object, msg, args...) -} - -// NotEqual asserts that the specified values are NOT equal. -// -// a.NotEqual(obj1, obj2) -// -// Pointer variable equality is determined based on the equality of the -// referenced values (as opposed to the memory addresses). -func (a *Assertions) NotEqual(expected interface{}, actual interface{}, msgAndArgs ...interface{}) { - NotEqual(a.t, expected, actual, msgAndArgs...) -} - -// NotEqualf asserts that the specified values are NOT equal. -// -// a.NotEqualf(obj1, obj2, "error message %s", "formatted") -// -// Pointer variable equality is determined based on the equality of the -// referenced values (as opposed to the memory addresses). -func (a *Assertions) NotEqualf(expected interface{}, actual interface{}, msg string, args ...interface{}) { - NotEqualf(a.t, expected, actual, msg, args...) -} - -// NotNil asserts that the specified object is not nil. -// -// a.NotNil(err) -func (a *Assertions) NotNil(object interface{}, msgAndArgs ...interface{}) { - NotNil(a.t, object, msgAndArgs...) -} - -// NotNilf asserts that the specified object is not nil. -// -// a.NotNilf(err, "error message %s", "formatted") -func (a *Assertions) NotNilf(object interface{}, msg string, args ...interface{}) { - NotNilf(a.t, object, msg, args...) -} - -// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic. -// -// a.NotPanics(func(){ RemainCalm() }) -func (a *Assertions) NotPanics(f assert.PanicTestFunc, msgAndArgs ...interface{}) { - NotPanics(a.t, f, msgAndArgs...) -} - -// NotPanicsf asserts that the code inside the specified PanicTestFunc does NOT panic. -// -// a.NotPanicsf(func(){ RemainCalm() }, "error message %s", "formatted") -func (a *Assertions) NotPanicsf(f assert.PanicTestFunc, msg string, args ...interface{}) { - NotPanicsf(a.t, f, msg, args...) -} - -// NotRegexp asserts that a specified regexp does not match a string. -// -// a.NotRegexp(regexp.MustCompile("starts"), "it's starting") -// a.NotRegexp("^start", "it's not starting") -func (a *Assertions) NotRegexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) { - NotRegexp(a.t, rx, str, msgAndArgs...) -} - -// NotRegexpf asserts that a specified regexp does not match a string. -// -// a.NotRegexpf(regexp.MustCompile("starts", "error message %s", "formatted"), "it's starting") -// a.NotRegexpf("^start", "it's not starting", "error message %s", "formatted") -func (a *Assertions) NotRegexpf(rx interface{}, str interface{}, msg string, args ...interface{}) { - NotRegexpf(a.t, rx, str, msg, args...) -} - -// NotSubset asserts that the specified list(array, slice...) contains not all -// elements given in the specified subset(array, slice...). -// -// a.NotSubset([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]") -func (a *Assertions) NotSubset(list interface{}, subset interface{}, msgAndArgs ...interface{}) { - NotSubset(a.t, list, subset, msgAndArgs...) -} - -// NotSubsetf asserts that the specified list(array, slice...) contains not all -// elements given in the specified subset(array, slice...). -// -// a.NotSubsetf([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted") -func (a *Assertions) NotSubsetf(list interface{}, subset interface{}, msg string, args ...interface{}) { - NotSubsetf(a.t, list, subset, msg, args...) -} - -// NotZero asserts that i is not the zero value for its type. -func (a *Assertions) NotZero(i interface{}, msgAndArgs ...interface{}) { - NotZero(a.t, i, msgAndArgs...) -} - -// NotZerof asserts that i is not the zero value for its type. -func (a *Assertions) NotZerof(i interface{}, msg string, args ...interface{}) { - NotZerof(a.t, i, msg, args...) -} - -// Panics asserts that the code inside the specified PanicTestFunc panics. -// -// a.Panics(func(){ GoCrazy() }) -func (a *Assertions) Panics(f assert.PanicTestFunc, msgAndArgs ...interface{}) { - Panics(a.t, f, msgAndArgs...) -} - -// PanicsWithValue asserts that the code inside the specified PanicTestFunc panics, and that -// the recovered panic value equals the expected panic value. -// -// a.PanicsWithValue("crazy error", func(){ GoCrazy() }) -func (a *Assertions) PanicsWithValue(expected interface{}, f assert.PanicTestFunc, msgAndArgs ...interface{}) { - PanicsWithValue(a.t, expected, f, msgAndArgs...) -} - -// PanicsWithValuef asserts that the code inside the specified PanicTestFunc panics, and that -// the recovered panic value equals the expected panic value. -// -// a.PanicsWithValuef("crazy error", func(){ GoCrazy() }, "error message %s", "formatted") -func (a *Assertions) PanicsWithValuef(expected interface{}, f assert.PanicTestFunc, msg string, args ...interface{}) { - PanicsWithValuef(a.t, expected, f, msg, args...) -} - -// Panicsf asserts that the code inside the specified PanicTestFunc panics. -// -// a.Panicsf(func(){ GoCrazy() }, "error message %s", "formatted") -func (a *Assertions) Panicsf(f assert.PanicTestFunc, msg string, args ...interface{}) { - Panicsf(a.t, f, msg, args...) -} - -// Regexp asserts that a specified regexp matches a string. -// -// a.Regexp(regexp.MustCompile("start"), "it's starting") -// a.Regexp("start...$", "it's not starting") -func (a *Assertions) Regexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) { - Regexp(a.t, rx, str, msgAndArgs...) -} - -// Regexpf asserts that a specified regexp matches a string. -// -// a.Regexpf(regexp.MustCompile("start", "error message %s", "formatted"), "it's starting") -// a.Regexpf("start...$", "it's not starting", "error message %s", "formatted") -func (a *Assertions) Regexpf(rx interface{}, str interface{}, msg string, args ...interface{}) { - Regexpf(a.t, rx, str, msg, args...) -} - -// Subset asserts that the specified list(array, slice...) contains all -// elements given in the specified subset(array, slice...). -// -// a.Subset([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]") -func (a *Assertions) Subset(list interface{}, subset interface{}, msgAndArgs ...interface{}) { - Subset(a.t, list, subset, msgAndArgs...) -} - -// Subsetf asserts that the specified list(array, slice...) contains all -// elements given in the specified subset(array, slice...). -// -// a.Subsetf([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted") -func (a *Assertions) Subsetf(list interface{}, subset interface{}, msg string, args ...interface{}) { - Subsetf(a.t, list, subset, msg, args...) -} - -// True asserts that the specified value is true. -// -// a.True(myBool) -func (a *Assertions) True(value bool, msgAndArgs ...interface{}) { - True(a.t, value, msgAndArgs...) -} - -// Truef asserts that the specified value is true. -// -// a.Truef(myBool, "error message %s", "formatted") -func (a *Assertions) Truef(value bool, msg string, args ...interface{}) { - Truef(a.t, value, msg, args...) -} - -// WithinDuration asserts that the two times are within duration delta of each other. -// -// a.WithinDuration(time.Now(), time.Now(), 10*time.Second) -func (a *Assertions) WithinDuration(expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) { - WithinDuration(a.t, expected, actual, delta, msgAndArgs...) -} - -// WithinDurationf asserts that the two times are within duration delta of each other. -// -// a.WithinDurationf(time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted") -func (a *Assertions) WithinDurationf(expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) { - WithinDurationf(a.t, expected, actual, delta, msg, args...) -} - -// Zero asserts that i is the zero value for its type. -func (a *Assertions) Zero(i interface{}, msgAndArgs ...interface{}) { - Zero(a.t, i, msgAndArgs...) -} - -// Zerof asserts that i is the zero value for its type. -func (a *Assertions) Zerof(i interface{}, msg string, args ...interface{}) { - Zerof(a.t, i, msg, args...) -} diff --git a/vendor/github.com/stretchr/testify/require/requirements.go b/vendor/github.com/stretchr/testify/require/requirements.go deleted file mode 100644 index e404f016d..000000000 --- a/vendor/github.com/stretchr/testify/require/requirements.go +++ /dev/null @@ -1,9 +0,0 @@ -package require - -// TestingT is an interface wrapper around *testing.T -type TestingT interface { - Errorf(format string, args ...interface{}) - FailNow() -} - -//go:generate go run ../_codegen/main.go -output-package=require -template=require.go.tmpl -include-format-funcs diff --git a/vkubelet/env_internal_test.go b/vkubelet/env_internal_test.go index b7475d269..cf11fe122 100644 --- a/vkubelet/env_internal_test.go +++ b/vkubelet/env_internal_test.go @@ -2,9 +2,12 @@ package vkubelet import ( "context" + "sort" "testing" - "github.com/stretchr/testify/assert" + gocmp "github.com/google/go-cmp/cmp" + "gotest.tools/assert" + is "gotest.tools/assert/cmp" corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -194,10 +197,10 @@ func TestPopulatePodWithInitContainersUsingEnv(t *testing.T) { // Populate the pod's environment. err := populateEnvironmentVariables(context.Background(), pod, rm, er) - assert.NoError(t, err) + assert.Check(t, err) // Make sure that all the containers' environments contain all the expected keys and values. - assert.ElementsMatch(t, pod.Spec.InitContainers[0].Env, []corev1.EnvVar{ + assert.Check(t, is.DeepEqual(pod.Spec.InitContainers[0].Env, []corev1.EnvVar{ { Name: envVarName1, Value: envVarValue1, @@ -206,8 +209,8 @@ func TestPopulatePodWithInitContainersUsingEnv(t *testing.T) { Name: envVarName2, Value: configMap1.Data[keyFoo], }, - }) - assert.ElementsMatch(t, pod.Spec.InitContainers[1].Env, []corev1.EnvVar{ + }, sortOpt)) + assert.Check(t, is.DeepEqual(pod.Spec.InitContainers[1].Env, []corev1.EnvVar{ { Name: envVarName1, Value: envVarValue1, @@ -216,8 +219,8 @@ func TestPopulatePodWithInitContainersUsingEnv(t *testing.T) { Name: envVarName2, Value: string(secret1.Data[keyBaz]), }, - }) - assert.ElementsMatch(t, pod.Spec.Containers[0].Env, []corev1.EnvVar{ + }, sortOpt)) + assert.Check(t, is.DeepEqual(pod.Spec.Containers[0].Env, []corev1.EnvVar{ { Name: envVarName1, Value: envVarValue1, @@ -226,8 +229,8 @@ func TestPopulatePodWithInitContainersUsingEnv(t *testing.T) { Name: envVarName2, Value: configMap1.Data[keyFoo], }, - }) - assert.ElementsMatch(t, pod.Spec.Containers[1].Env, []corev1.EnvVar{ + }, sortOpt)) + assert.Check(t, is.DeepEqual(pod.Spec.Containers[1].Env, []corev1.EnvVar{ { Name: envVarName1, Value: envVarValue1, @@ -236,7 +239,7 @@ func TestPopulatePodWithInitContainersUsingEnv(t *testing.T) { Name: envVarName2, Value: string(secret1.Data[keyBaz]), }, - }) + }, sortOpt)) } // TestPopulatePodWithInitContainersUsingEnv populates the environment of a pod with four containers (two init containers, two containers) using ".env". @@ -353,10 +356,10 @@ func TestPopulatePodWithInitContainersUsingEnvWithFieldRef(t *testing.T) { // Populate the pod's environment. err := populateEnvironmentVariables(context.Background(), pod, rm, er) - assert.NoError(t, err) + assert.NilError(t, err) // Make sure that all the containers' environments contain all the expected keys and values. - assert.ElementsMatch(t, pod.Spec.InitContainers[0].Env, []corev1.EnvVar{ + assert.Check(t, is.DeepEqual(pod.Spec.InitContainers[0].Env, []corev1.EnvVar{ { Name: envVarName1, @@ -374,9 +377,9 @@ func TestPopulatePodWithInitContainersUsingEnvWithFieldRef(t *testing.T) { Name: envVarName4, Value: "serviceaccount", }, - }) + }, sortOpt)) - assert.ElementsMatch(t, pod.Spec.Containers[0].Env, []corev1.EnvVar{ + assert.Check(t, is.DeepEqual(pod.Spec.Containers[0].Env, []corev1.EnvVar{ { Name: envVarName1, @@ -394,7 +397,7 @@ func TestPopulatePodWithInitContainersUsingEnvWithFieldRef(t *testing.T) { Name: envVarName4, Value: "serviceaccount", }, - }) + }, sortOpt)) } // TestPopulatePodWithInitContainersUsingEnvFrom populates the environment of a pod with four containers (two init containers, two containers) using ".envFrom". @@ -468,33 +471,33 @@ func TestPopulatePodWithInitContainersUsingEnvFrom(t *testing.T) { // Populate the pod's environment. err := populateEnvironmentVariables(context.Background(), pod, rm, er) - assert.NoError(t, err) + assert.Check(t, err) // Make sure that all the containers' environments contain all the expected keys and values. - assert.ElementsMatch(t, pod.Spec.InitContainers[0].Env, []corev1.EnvVar{ + assert.Check(t, is.DeepEqual(pod.Spec.InitContainers[0].Env, []corev1.EnvVar{ { Name: prefixConfigMap1 + keyFoo, Value: configMap1.Data[keyFoo], }, - }) - assert.ElementsMatch(t, pod.Spec.InitContainers[1].Env, []corev1.EnvVar{ + }, sortOpt)) + assert.Check(t, is.DeepEqual(pod.Spec.InitContainers[1].Env, []corev1.EnvVar{ { Name: prefixConfigMap2 + keyBar, Value: configMap2.Data[keyBar], }, - }) - assert.ElementsMatch(t, pod.Spec.Containers[0].Env, []corev1.EnvVar{ + }, sortOpt)) + assert.Check(t, is.DeepEqual(pod.Spec.Containers[0].Env, []corev1.EnvVar{ { Name: prefixSecret1 + keyBaz, Value: string(secret1.Data[keyBaz]), }, - }) - assert.ElementsMatch(t, pod.Spec.Containers[1].Env, []corev1.EnvVar{ + }, sortOpt)) + assert.Check(t, is.DeepEqual(pod.Spec.Containers[1].Env, []corev1.EnvVar{ { Name: prefixSecret2 + keyFoo, Value: string(secret2.Data[keyFoo]), }, - }) + }, sortOpt)) } // TestEnvFromTwoConfigMapsAndOneSecret populates the environment of a container from two configmaps and one secret. @@ -546,10 +549,10 @@ func TestEnvFromTwoConfigMapsAndOneSecret(t *testing.T) { // Populate the container's environment. err := populateContainerEnvironment(context.Background(), pod, &pod.Spec.Containers[0], rm, er) - assert.NoError(t, err) + assert.Check(t, err) // Make sure that the container's environment contains all the expected keys and values. - assert.ElementsMatch(t, pod.Spec.Containers[0].Env, []corev1.EnvVar{ + assert.Check(t, is.DeepEqual(pod.Spec.Containers[0].Env, []corev1.EnvVar{ { Name: prefixConfigMap1 + keyFoo, Value: configMap1.Data[keyFoo], @@ -562,10 +565,10 @@ func TestEnvFromTwoConfigMapsAndOneSecret(t *testing.T) { Name: prefixSecret1 + keyBaz, Value: string(secret1.Data[keyBaz]), }, - }) + }, sortOpt)) // Make sure that no events have been recorded, as the configmaps and secrets are valid. - assert.Len(t, er.Events, 0) + assert.Check(t, is.Len(er.Events, 0)) } // TestEnvFromConfigMapAndSecretWithInvalidKeys populates the environment of a container from a configmap and a secret containing invalid keys. @@ -607,10 +610,10 @@ func TestEnvFromConfigMapAndSecretWithInvalidKeys(t *testing.T) { // Populate the pods's environment. err := populateEnvironmentVariables(context.Background(), pod, rm, er) - assert.NoError(t, err) + assert.Check(t, err) // Make sure that the container's environment has two variables (corresponding to the single valid key in both the configmap and the secret). - assert.ElementsMatch(t, pod.Spec.Containers[0].Env, []corev1.EnvVar{ + assert.Check(t, is.DeepEqual(pod.Spec.Containers[0].Env, []corev1.EnvVar{ { Name: keyFoo, Value: invalidConfigMap1.Data[keyFoo], @@ -619,21 +622,21 @@ func TestEnvFromConfigMapAndSecretWithInvalidKeys(t *testing.T) { Name: keyBaz, Value: string(invalidSecret1.Data[keyBaz]), }, - }) + }, sortOpt)) // Make sure that two events have been received (one for the configmap and one for the secret). - assert.Len(t, er.Events, 2) + assert.Check(t, is.Len(er.Events, 2)) // Grab the first event (which should correspond to the configmap) and make sure it has the correct reason and message. event1 := <-er.Events - assert.Contains(t, event1, ReasonInvalidEnvironmentVariableNames) - assert.Contains(t, event1, invalidKey1) - assert.Contains(t, event1, invalidKey2) + assert.Check(t, is.Contains(event1, ReasonInvalidEnvironmentVariableNames)) + assert.Check(t, is.Contains(event1, invalidKey1)) + assert.Check(t, is.Contains(event1, invalidKey2)) // Grab the second event (which should correspond to the secret) and make sure it has the correct reason and message. event2 := <-er.Events - assert.Contains(t, event2, ReasonInvalidEnvironmentVariableNames) - assert.Contains(t, event2, invalidKey3) + assert.Check(t, is.Contains(event2, ReasonInvalidEnvironmentVariableNames)) + assert.Check(t, is.Contains(event2, invalidKey3)) } // TestEnvOverridesEnvFrom populates the environment of a container from a configmap, and from another configmap's key with a "conflicting" key. @@ -677,10 +680,10 @@ func TestEnvOverridesEnvFrom(t *testing.T) { // Populate the pods's environment. err := populateEnvironmentVariables(context.Background(), pod, rm, er) - assert.NoError(t, err) + assert.Check(t, err) // Make sure that the container's environment contains all the expected keys and values. - assert.ElementsMatch(t, pod.Spec.Containers[0].Env, []corev1.EnvVar{ + assert.Check(t, is.DeepEqual(pod.Spec.Containers[0].Env, []corev1.EnvVar{ { Name: keyFoo, Value: override, @@ -689,10 +692,22 @@ func TestEnvOverridesEnvFrom(t *testing.T) { Name: keyBar, Value: configMap3.Data[keyBar], }, - }) + }, + sortOpt, + )) // Make sure that no events have been recorded, as the configmaps and secrets are valid. - assert.Len(t, er.Events, 0) + assert.Check(t, is.Len(er.Events, 0)) +} + +var sortOpt gocmp.Option = gocmp.Transformer("Sort", sortEnv) + +func sortEnv(in []corev1.EnvVar) []corev1.EnvVar { + out := append([]corev1.EnvVar(nil), in...) + sort.Slice(out, func(i, j int) bool { + return out[i].Name < out[j].Name + }) + return out } // TestEnvFromInexistentConfigMaps populates the environment of a container from two configmaps (one of them optional) that do not exist. @@ -741,16 +756,16 @@ func TestEnvFromInexistentConfigMaps(t *testing.T) { // Populate the pods's environment. err := populateEnvironmentVariables(context.Background(), pod, rm, er) - assert.Error(t, err) + assert.Check(t, is.ErrorContains(err, "")) // Make sure that two events have been recorded with the correct reason and message. - assert.Len(t, er.Events, 2) + assert.Check(t, is.Len(er.Events, 2)) event1 := <-er.Events - assert.Contains(t, event1, ReasonOptionalConfigMapNotFound) - assert.Contains(t, event1, missingConfigMap1Name) + assert.Check(t, is.Contains(event1, ReasonOptionalConfigMapNotFound)) + assert.Check(t, is.Contains(event1, missingConfigMap1Name)) event2 := <-er.Events - assert.Contains(t, event2, ReasonMandatoryConfigMapNotFound) - assert.Contains(t, event2, missingConfigMap2Name) + assert.Check(t, is.Contains(event2, ReasonMandatoryConfigMapNotFound)) + assert.Check(t, is.Contains(event2, missingConfigMap2Name)) } func TestEnvFromInexistentSecrets(t *testing.T) { @@ -797,16 +812,16 @@ func TestEnvFromInexistentSecrets(t *testing.T) { // Populate the pods's environment. err := populateEnvironmentVariables(context.Background(), pod, rm, er) - assert.Error(t, err) + assert.Check(t, is.ErrorContains(err, "")) // Make sure that two events have been recorded with the correct reason and message. - assert.Len(t, er.Events, 2) + assert.Check(t, is.Len(er.Events, 2)) event1 := <-er.Events - assert.Contains(t, event1, ReasonOptionalSecretNotFound) - assert.Contains(t, event1, missingSecret1Name) + assert.Check(t, is.Contains(event1, ReasonOptionalSecretNotFound)) + assert.Check(t, is.Contains(event1, missingSecret1Name)) event2 := <-er.Events - assert.Contains(t, event2, ReasonMandatorySecretNotFound) - assert.Contains(t, event2, missingSecret2Name) + assert.Check(t, is.Contains(event2, ReasonMandatorySecretNotFound)) + assert.Check(t, is.Contains(event2, missingSecret2Name)) } // TestEnvReferencingInexistentConfigMapKey tries populates the environment of a container using a keys from a configmaps that does not exist. @@ -849,13 +864,13 @@ func TestEnvReferencingInexistentConfigMapKey(t *testing.T) { // Populate the pods's environment. err := populateEnvironmentVariables(context.Background(), pod, rm, er) - assert.Error(t, err) + assert.Check(t, is.ErrorContains(err, "")) // Make sure that two events have been recorded with the correct reason and message. - assert.Len(t, er.Events, 1) + assert.Check(t, is.Len(er.Events, 1)) event1 := <-er.Events - assert.Contains(t, event1, ReasonMandatoryConfigMapNotFound) - assert.Contains(t, event1, missingConfigMapName) + assert.Check(t, is.Contains(event1, ReasonMandatoryConfigMapNotFound)) + assert.Check(t, is.Contains(event1, missingConfigMapName)) } // TestEnvReferencingInexistentSecretKey tries populates the environment of a container using a keys from a secret that does not exist. @@ -898,11 +913,11 @@ func TestEnvReferencingInexistentSecretKey(t *testing.T) { // Populate the pods's environment. err := populateEnvironmentVariables(context.Background(), pod, rm, er) - assert.Error(t, err) + assert.Check(t, is.ErrorContains(err, "")) // Make sure that two events have been recorded with the correct reason and message. - assert.Len(t, er.Events, 1) + assert.Check(t, is.Len(er.Events, 1)) event1 := <-er.Events - assert.Contains(t, event1, ReasonMandatorySecretNotFound) - assert.Contains(t, event1, missingSecretName) + assert.Check(t, is.Contains(event1, ReasonMandatorySecretNotFound)) + assert.Check(t, is.Contains(event1, missingSecretName)) }