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

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

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

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

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

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

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

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

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

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

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

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

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

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

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