Use the assert/require package in kubelet unit tests

pkg/kubelet/kubelet_cadvisor_test.go

@@ -20,6 +20,9 @@ import (
 	"fmt"
 	"testing"
 
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
 	cadvisorapi "github.com/google/cadvisor/info/v1"
 	cadvisorapiv2 "github.com/google/cadvisor/info/v2"
 	"k8s.io/apimachinery/pkg/types"
@@ -194,11 +197,10 @@ func TestGetContainerInfo(t *testing.T) {
 		fakeRuntime.PodList = tc.podList
 
 		stats, err := kubelet.GetContainerInfo(tc.requestedPodFullName, tc.requestedPodUid, tc.requestedContainerName, cadvisorReq)
-		if err != tc.expectedError {
-			t.Errorf("test '%s' failed: expected error %#v, got %#v", tc.name, tc.expectedError, err)
-		}
-		if tc.expectStats && stats == nil {
-			t.Fatalf("test '%s' failed: stats should not be nil", tc.name)
+		assert.Equal(t, tc.expectedError, err)
+
+		if tc.expectStats {
+			require.NotNil(t, stats)
 		}
 		mockCadvisor.AssertExpectations(t)
 	}
@@ -219,9 +221,7 @@ func TestGetRawContainerInfoRoot(t *testing.T) {
 	mockCadvisor.On("ContainerInfo", containerPath, cadvisorReq).Return(containerInfo, nil)
 
 	_, err := kubelet.GetRawContainerInfo(containerPath, cadvisorReq, false)
-	if err != nil {
-		t.Errorf("unexpected error: %v", err)
-	}
+	assert.NoError(t, err)
 	mockCadvisor.AssertExpectations(t)
 }
 
@@ -247,12 +247,8 @@ func TestGetRawContainerInfoSubcontainers(t *testing.T) {
 	mockCadvisor.On("SubcontainerInfo", containerPath, cadvisorReq).Return(containerInfo, nil)
 
 	result, err := kubelet.GetRawContainerInfo(containerPath, cadvisorReq, true)
-	if err != nil {
-		t.Errorf("unexpected error: %v", err)
-	}
-	if len(result) != 2 {
-		t.Errorf("Expected 2 elements, received: %#v", result)
-	}
+	assert.NoError(t, err)
+	assert.Len(t, result, 2)
 	mockCadvisor.AssertExpectations(t)
 }
 
@@ -282,11 +278,7 @@ func TestHasDedicatedImageFs(t *testing.T) {
 		mockCadvisor.On("ImagesFsInfo").Return(testCase.imageFsInfo, nil)
 		mockCadvisor.On("RootFsInfo").Return(testCase.rootFsInfo, nil)
 		actual, err := kubelet.HasDedicatedImageFs()
-		if err != nil {
-			t.Errorf("case: %s, unexpected error: %v", testName, err)
-		}
-		if actual != testCase.expected {
-			t.Errorf("case: %s, expected: %v, actual: %v", testName, testCase.expected, actual)
-		}
+		assert.NoError(t, err, "test [%s]", testName)
+		assert.Equal(t, testCase.expected, actual, "test [%s]", testName)
 	}
 }

pkg/kubelet/kubelet_getters_test.go

@@ -21,6 +21,9 @@ import (
 	"os"
 	"path/filepath"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestKubeletDirs(t *testing.T) {
@@ -33,57 +36,39 @@ func TestKubeletDirs(t *testing.T) {
 
 	got = kubelet.getPodsDir()
 	exp = filepath.Join(root, "pods")
-	if got != exp {
-		t.Errorf("expected %q', got %q", exp, got)
-	}
+	assert.Equal(t, exp, got)
 
 	got = kubelet.getPluginsDir()
 	exp = filepath.Join(root, "plugins")
-	if got != exp {
-		t.Errorf("expected %q', got %q", exp, got)
-	}
+	assert.Equal(t, exp, got)
 
 	got = kubelet.getPluginDir("foobar")
 	exp = filepath.Join(root, "plugins/foobar")
-	if got != exp {
-		t.Errorf("expected %q', got %q", exp, got)
-	}
+	assert.Equal(t, exp, got)
 
 	got = kubelet.getPodDir("abc123")
 	exp = filepath.Join(root, "pods/abc123")
-	if got != exp {
-		t.Errorf("expected %q', got %q", exp, got)
-	}
+	assert.Equal(t, exp, got)
 
 	got = kubelet.getPodVolumesDir("abc123")
 	exp = filepath.Join(root, "pods/abc123/volumes")
-	if got != exp {
-		t.Errorf("expected %q', got %q", exp, got)
-	}
+	assert.Equal(t, exp, got)
 
 	got = kubelet.getPodVolumeDir("abc123", "plugin", "foobar")
 	exp = filepath.Join(root, "pods/abc123/volumes/plugin/foobar")
-	if got != exp {
-		t.Errorf("expected %q', got %q", exp, got)
-	}
+	assert.Equal(t, exp, got)
 
 	got = kubelet.getPodPluginsDir("abc123")
 	exp = filepath.Join(root, "pods/abc123/plugins")
-	if got != exp {
-		t.Errorf("expected %q', got %q", exp, got)
-	}
+	assert.Equal(t, exp, got)
 
 	got = kubelet.getPodPluginDir("abc123", "foobar")
 	exp = filepath.Join(root, "pods/abc123/plugins/foobar")
-	if got != exp {
-		t.Errorf("expected %q', got %q", exp, got)
-	}
+	assert.Equal(t, exp, got)
 
 	got = kubelet.getPodContainerDir("abc123", "def456")
 	exp = filepath.Join(root, "pods/abc123/containers/def456")
-	if got != exp {
-		t.Errorf("expected %q', got %q", exp, got)
-	}
+	assert.Equal(t, exp, got)
 }
 
 func TestKubeletDirsCompat(t *testing.T) {
@@ -91,91 +76,37 @@ func TestKubeletDirsCompat(t *testing.T) {
 	defer testKubelet.Cleanup()
 	kubelet := testKubelet.kubelet
 	root := kubelet.rootDirectory
-	if err := os.MkdirAll(root, 0750); err != nil {
-		t.Fatalf("can't mkdir(%q): %s", root, err)
-	}
-
-	var exp, got string
+	require.NoError(t, os.MkdirAll(root, 0750), "can't mkdir(%q)", root)
 
 	// Old-style pod dir.
-	if err := os.MkdirAll(fmt.Sprintf("%s/oldpod", root), 0750); err != nil {
-		t.Fatalf("can't mkdir(%q): %s", root, err)
-	}
+	require.NoError(t, os.MkdirAll(fmt.Sprintf("%s/oldpod", root), 0750), "can't mkdir(%q)", root)
+
 	// New-style pod dir.
-	if err := os.MkdirAll(fmt.Sprintf("%s/pods/newpod", root), 0750); err != nil {
-		t.Fatalf("can't mkdir(%q): %s", root, err)
-	}
+	require.NoError(t, os.MkdirAll(fmt.Sprintf("%s/pods/newpod", root), 0750), "can't mkdir(%q)", root)
+
 	// Both-style pod dir.
-	if err := os.MkdirAll(fmt.Sprintf("%s/bothpod", root), 0750); err != nil {
-		t.Fatalf("can't mkdir(%q): %s", root, err)
-	}
-	if err := os.MkdirAll(fmt.Sprintf("%s/pods/bothpod", root), 0750); err != nil {
-		t.Fatalf("can't mkdir(%q): %s", root, err)
-	}
-
-	got = kubelet.getPodDir("oldpod")
-	exp = filepath.Join(root, "oldpod")
-	if got != exp {
-		t.Errorf("expected %q', got %q", exp, got)
-	}
-
-	got = kubelet.getPodDir("newpod")
-	exp = filepath.Join(root, "pods/newpod")
-	if got != exp {
-		t.Errorf("expected %q', got %q", exp, got)
-	}
-
-	got = kubelet.getPodDir("bothpod")
-	exp = filepath.Join(root, "pods/bothpod")
-	if got != exp {
-		t.Errorf("expected %q', got %q", exp, got)
-	}
-
-	got = kubelet.getPodDir("neitherpod")
-	exp = filepath.Join(root, "pods/neitherpod")
-	if got != exp {
-		t.Errorf("expected %q', got %q", exp, got)
-	}
+	require.NoError(t, os.MkdirAll(fmt.Sprintf("%s/bothpod", root), 0750), "can't mkdir(%q)", root)
+	require.NoError(t, os.MkdirAll(fmt.Sprintf("%s/pods/bothpod", root), 0750), "can't mkdir(%q)", root)
+
+	assert.Equal(t, filepath.Join(root, "oldpod"), kubelet.getPodDir("oldpod"))
+	assert.Equal(t, filepath.Join(root, "pods/newpod"), kubelet.getPodDir("newpod"))
+	assert.Equal(t, filepath.Join(root, "pods/bothpod"), kubelet.getPodDir("bothpod"))
+	assert.Equal(t, filepath.Join(root, "pods/neitherpod"), kubelet.getPodDir("neitherpod"))
 
 	root = kubelet.getPodDir("newpod")
 
 	// Old-style container dir.
-	if err := os.MkdirAll(fmt.Sprintf("%s/oldctr", root), 0750); err != nil {
-		t.Fatalf("can't mkdir(%q): %s", root, err)
-	}
+	require.NoError(t, os.MkdirAll(fmt.Sprintf("%s/oldctr", root), 0750), "can't mkdir(%q)", root)
+
 	// New-style container dir.
-	if err := os.MkdirAll(fmt.Sprintf("%s/containers/newctr", root), 0750); err != nil {
-		t.Fatalf("can't mkdir(%q): %s", root, err)
-	}
+	require.NoError(t, os.MkdirAll(fmt.Sprintf("%s/containers/newctr", root), 0750), "can't mkdir(%q)", root)
+
 	// Both-style container dir.
-	if err := os.MkdirAll(fmt.Sprintf("%s/bothctr", root), 0750); err != nil {
-		t.Fatalf("can't mkdir(%q): %s", root, err)
-	}
-	if err := os.MkdirAll(fmt.Sprintf("%s/containers/bothctr", root), 0750); err != nil {
-		t.Fatalf("can't mkdir(%q): %s", root, err)
-	}
-
-	got = kubelet.getPodContainerDir("newpod", "oldctr")
-	exp = filepath.Join(root, "oldctr")
-	if got != exp {
-		t.Errorf("expected %q', got %q", exp, got)
-	}
-
-	got = kubelet.getPodContainerDir("newpod", "newctr")
-	exp = filepath.Join(root, "containers/newctr")
-	if got != exp {
-		t.Errorf("expected %q', got %q", exp, got)
-	}
-
-	got = kubelet.getPodContainerDir("newpod", "bothctr")
-	exp = filepath.Join(root, "containers/bothctr")
-	if got != exp {
-		t.Errorf("expected %q', got %q", exp, got)
-	}
-
-	got = kubelet.getPodContainerDir("newpod", "neitherctr")
-	exp = filepath.Join(root, "containers/neitherctr")
-	if got != exp {
-		t.Errorf("expected %q', got %q", exp, got)
-	}
+	require.NoError(t, os.MkdirAll(fmt.Sprintf("%s/bothctr", root), 0750), "can't mkdir(%q)", root)
+	require.NoError(t, os.MkdirAll(fmt.Sprintf("%s/containers/bothctr", root), 0750), "can't mkdir(%q)", root)
+
+	assert.Equal(t, filepath.Join(root, "oldctr"), kubelet.getPodContainerDir("newpod", "oldctr"))
+	assert.Equal(t, filepath.Join(root, "containers/newctr"), kubelet.getPodContainerDir("newpod", "newctr"))
+	assert.Equal(t, filepath.Join(root, "containers/bothctr"), kubelet.getPodContainerDir("newpod", "bothctr"))
+	assert.Equal(t, filepath.Join(root, "containers/neitherctr"), kubelet.getPodContainerDir("newpod", "neitherctr"))
 }

pkg/kubelet/kubelet_network_test.go

@@ -19,10 +19,11 @@ package kubelet
 import (
 	"fmt"
 	"net"
-	"reflect"
 	"strings"
 	"testing"
 
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"k8s.io/client-go/tools/record"
 	"k8s.io/kubernetes/pkg/api/v1"
 	"k8s.io/kubernetes/pkg/util/bandwidth"
@@ -61,10 +62,10 @@ func TestNodeIPParam(t *testing.T) {
 	for _, test := range tests {
 		kubelet.nodeIP = net.ParseIP(test.nodeIP)
 		err := kubelet.validateNodeIP()
-		if err != nil && test.success {
-			t.Errorf("Test: %s, expected no error but got: %v", test.testName, err)
-		} else if err == nil && !test.success {
-			t.Errorf("Test: %s, expected an error", test.testName)
+		if test.success {
+			assert.NoError(t, err, "test %s", test.testName)
+		} else {
+			assert.Error(t, err, fmt.Sprintf("test %s", test.testName))
 		}
 	}
 }
@@ -103,16 +104,9 @@ func TestParseResolvConf(t *testing.T) {
 	kubelet := testKubelet.kubelet
 	for i, tc := range testCases {
 		ns, srch, err := kubelet.parseResolvConf(strings.NewReader(tc.data))
-		if err != nil {
-			t.Errorf("expected success, got %v", err)
-			continue
-		}
-		if !reflect.DeepEqual(ns, tc.nameservers) {
-			t.Errorf("[%d] expected nameservers %#v, got %#v", i, tc.nameservers, ns)
-		}
-		if !reflect.DeepEqual(srch, tc.searches) {
-			t.Errorf("[%d] expected searches %#v, got %#v", i, tc.searches, srch)
-		}
+		require.NoError(t, err)
+		assert.EqualValues(t, tc.nameservers, ns, "test case [%d]: name servers", i)
+		assert.EqualValues(t, tc.searches, srch, "test case [%d] searches", i)
 	}
 }
 
@@ -179,17 +173,11 @@ func TestComposeDNSSearch(t *testing.T) {
 
 	for i, tc := range testCases {
 		dnsSearch := kubelet.formDNSSearch(tc.hostNames, pod)
-
-		if !reflect.DeepEqual(dnsSearch, tc.resultSearch) {
-			t.Errorf("[%d] expected search line %#v, got %#v", i, tc.resultSearch, dnsSearch)
-		}
-
+		assert.EqualValues(t, tc.resultSearch, dnsSearch, "test [%d]", i)
 		for _, expectedEvent := range tc.events {
 			expected := fmt.Sprintf("%s %s %s", v1.EventTypeWarning, "DNSSearchForming", expectedEvent)
 			event := fetchEvent(recorder)
-			if event != expected {
-				t.Errorf("[%d] expected event '%s', got '%s", i, expected, event)
-			}
+			assert.Equal(t, expected, event, "test [%d]", i)
 		}
 	}
 }
@@ -268,12 +256,8 @@ func TestCleanupBandwidthLimits(t *testing.T) {
 		}
 
 		err := testKube.kubelet.cleanupBandwidthLimits(test.pods)
-		if err != nil {
-			t.Errorf("unexpected error: %v (%s)", test.name, err)
-		}
-		if !reflect.DeepEqual(shaper.ResetCIDRs, test.expectResetCIDRs) {
-			t.Errorf("[%s]\nexpected: %v, saw: %v", test.name, test.expectResetCIDRs, shaper.ResetCIDRs)
-		}
+		assert.NoError(t, err, "test [%s]", test.name)
+		assert.EqualValues(t, test.expectResetCIDRs, shaper.ResetCIDRs, "test[%s]", test.name)
 	}
 }
 
@@ -293,8 +277,6 @@ func TestGetIPTablesMark(t *testing.T) {
 	}
 	for _, tc := range tests {
 		res := getIPTablesMark(tc.bit)
-		if res != tc.expect {
-			t.Errorf("getIPTablesMark output unexpected result: %v when input bit is %d. Expect result: %v", res, tc.bit, tc.expect)
-		}
+		assert.Equal(t, tc.expect, res, "input %d", tc.bit)
 	}
 }

pkg/kubelet/kubelet_volumes_test.go

@@ -68,19 +68,13 @@ func TestListVolumesForPod(t *testing.T) {
 	podName := volumehelper.GetUniquePodName(pod)
 
 	volumesToReturn, volumeExsit := kubelet.ListVolumesForPod(types.UID(podName))
-	if !volumeExsit {
-		t.Errorf("Expected to find volumes for pod %q, but ListVolumesForPod find no volume", podName)
-	}
+	assert.True(t, volumeExsit, "expected to find volumes for pod %q", podName)
 
 	outerVolumeSpecName1 := "vol1"
-	if volumesToReturn[outerVolumeSpecName1] == nil {
-		t.Errorf("Value of map volumesToReturn is not expected to be nil, which key is : %s", outerVolumeSpecName1)
-	}
+	assert.NotNil(t, volumesToReturn[outerVolumeSpecName1], "key %s", outerVolumeSpecName1)
 
 	outerVolumeSpecName2 := "vol2"
-	if volumesToReturn[outerVolumeSpecName2] == nil {
-		t.Errorf("Value of map volumesToReturn is not expected to be nil, which key is : %s", outerVolumeSpecName2)
-	}
+	assert.NotNil(t, volumesToReturn[outerVolumeSpecName2], "key %s", outerVolumeSpecName2)
 
 }
 
@@ -154,18 +148,12 @@ func TestPodVolumesExist(t *testing.T) {
 	kubelet.podManager.SetPods(pods)
 	for _, pod := range pods {
 		err := kubelet.volumeManager.WaitForAttachAndMount(pod)
-		if err != nil {
-			t.Errorf("Expected success: %v", err)
-		}
+		assert.NoError(t, err)
 	}
 
 	for _, pod := range pods {
 		podVolumesExist := kubelet.podVolumesExist(pod.UID)
-		if !podVolumesExist {
-			t.Errorf(
-				"Expected to find volumes for pod %q, but podVolumesExist returned false",
-				pod.UID)
-		}
+		assert.True(t, podVolumesExist, "pod %q", pod.UID)
 	}
 }
 

pkg/kubelet/oom_watcher_test.go

@@ -19,6 +19,8 @@ package kubelet
 import (
 	"testing"
 
+	"github.com/stretchr/testify/assert"
+
 	"k8s.io/client-go/pkg/api/v1"
 	"k8s.io/client-go/tools/record"
 	cadvisortest "k8s.io/kubernetes/pkg/kubelet/cadvisor/testing"
@@ -29,10 +31,7 @@ func TestBasic(t *testing.T) {
 	mockCadvisor := &cadvisortest.Fake{}
 	node := &v1.ObjectReference{}
 	oomWatcher := NewOOMWatcher(mockCadvisor, fakeRecorder)
-	err := oomWatcher.Start(node)
-	if err != nil {
-		t.Errorf("Should not have failed: %v", err)
-	}
+	assert.NoError(t, oomWatcher.Start(node))
 
 	// TODO: Improve this test once cadvisor exports events.EventChannel as an interface
 	// and thereby allow using a mock version of cadvisor.