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

Replace testify with gotest.tools (#553)

Browse Source 
* vendor gotest.tools

* Run gotest.tools migration tools

* Fixup tests that were improperly converted

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

6
Gopkg.lock generated
View File

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

4
Gopkg.toml
View File

@@ -137,3 +137,7 @@
name = "github.com/virtual-kubelet/azure-aci"
version = "v0.1.0"
[[constraint]]
name = "gotest.tools"
version = "2.3.0"

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

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

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

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

233
providers/azure/aci_test.go
View File

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

53
providers/huawei/cci_test.go
View File

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

13
providers/nomad/nomad_test.go
View File

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

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

@@ -4,9 +4,10 @@ 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"
)
@@ -21,7 +22,7 @@ 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{
@@ -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,7 +52,7 @@ 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{
@@ -61,16 +62,16 @@ func TestAdd(t *testing.T) {
// Positive cases
err = c.Add(op, "namespace1", "testpod1a", &vp)
assert.Nil(t, err, "PodCache.Add failed with error: %s", err)
assert.Check(t, err, "PodCache.Add failed with error: %s", err)
// Negative cases
err = c.Add(op, "namespace1", "", &vp)
assert.NotNil(t, err, "PodCache.Add expected error for empty name")
assert.Equal(t, err, PodCachePodNameError)
assert.Check(t, err != nil, "PodCache.Add expected error for empty name")
assert.Check(t, is.DeepEqual(err, PodCachePodNameError))
err = c.Add(op, "namespace1", "test2", nil)
assert.NotNil(t, err, "PodCache.Add expected error for nil pod")
assert.Equal(t, err, PodCacheNilPodError)
assert.Check(t, err != nil, "PodCache.Add expected error for nil pod")
assert.Check(t, is.DeepEqual(err, PodCacheNilPodError))
}
func TestGet(t *testing.T) {
@@ -82,17 +83,17 @@ func TestGet(t *testing.T) {
// Positive cases
vpod, err = c.Get(op, "namespace1", "testpod1a")
assert.Nil(t, err, "PodCache.Get failed with error: %s", err)
assert.NotNil(t, vpod, "PodCache.Get expected to return non-nil pod but received nil")
assert.Check(t, err, "PodCache.Get failed with error: %s", err)
assert.Check(t, vpod != nil, "PodCache.Get expected to return non-nil pod but received nil")
vpod, err = c.Get(op, "namespace2", "testpod2a")
assert.Nil(t, err, "PodCache.Get failed with error: %s", err)
assert.NotNil(t, vpod, "PodCache.Get expected to return non-nil pod but received nil")
assert.Check(t, err, "PodCache.Get failed with error: %s", err)
assert.Check(t, vpod != nil, "PodCache.Get expected to return non-nil pod but received nil")
// Negative cases
vpod, err = c.Get(op, "namespace1", "")
assert.Equal(t, err, PodCachePodNameError)
assert.Nil(t, vpod, "PodCache.Get expected to return nil pod but received non-nil")
assert.Check(t, is.DeepEqual(err, PodCachePodNameError))
assert.Check(t, is.Nil(vpod), "PodCache.Get expected to return nil pod but received non-nil")
//TODO: uncomment out once namespace support added to cache
//vpod, err = c.Get(op, "namespace1", "testpod2a")
@@ -108,8 +109,8 @@ func TestGetAll(t *testing.T) {
c := setup(t, op)
vps := c.GetAll(op)
assert.NotNil(t, vps, "PodCache.GetAll returned nil slice")
assert.Len(t, vps, 4, "PodCache.Get did not return all pod definitions. Returned %d pods.", len(vps))
assert.Check(t, vps != nil, "PodCache.GetAll returned nil slice")
assert.Check(t, is.Len(vps, 4), "PodCache.Get did not return all pod definitions. Returned %d pods.", len(vps))
}
func TestDelete(t *testing.T) {
@@ -120,13 +121,13 @@ func TestDelete(t *testing.T) {
// Positive cases
err = c.Delete(op, "namespace1", "testpod1a")
assert.Nil(t, err, "PodCache.Delete failed with error: %s", err)
assert.Check(t, err, "PodCache.Delete failed with error: %s", err)
vps := c.GetAll(op)
assert.Len(t, vps, 3, "PodCache.Delete did not delete pod.")
assert.Check(t, is.Len(vps, 3), "PodCache.Delete did not delete pod.")
// Negative cases
err = c.Delete(op, "namespace2", "")
assert.Equal(t, err, PodCachePodNameError)
assert.Check(t, is.DeepEqual(err, PodCachePodNameError))
//TODO: uncomment the tests below once namespace support added to cache
//vps = c.GetAll(op)
@@ -136,4 +137,3 @@ func TestDelete(t *testing.T) {
//vps = c.GetAll(op)
//assert.Len(t, vps, currCount, "PodCache.Delete ignored namespace")
}

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

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

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

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

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

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

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

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

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

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

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

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

28
vendor/github.com/stretchr/testify/require/doc.go generated vendored
View File

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

16
vendor/github.com/stretchr/testify/require/forward_requirements.go generated vendored
View File

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

867
vendor/github.com/stretchr/testify/require/require.go generated vendored
View File

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

687
vendor/github.com/stretchr/testify/require/require_forward.go generated vendored
View File

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

9
vendor/github.com/stretchr/testify/require/requirements.go generated vendored
View File

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

137
vkubelet/env_internal_test.go
View File

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