Use the assert/require package in kubelet unit tests

This reduce the lines of code and improve readability.

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