tests: Port kubelet tests to Windows

Ports kubelet/util unit tests to Windows.

pkg/kubelet/util/util_test.go

@@ -17,9 +17,12 @@ limitations under the License.
 package util
 
 import (
+	"net"
+	"os"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestGetNodenameForKernel(t *testing.T) {
@@ -86,3 +89,63 @@ func TestGetNodenameForKernel(t *testing.T) {
 	}
 
 }
+
+func TestIsUnixDomainSocket(t *testing.T) {
+	tests := []struct {
+		label          string
+		listenOnSocket bool
+		expectSocket   bool
+		expectError    bool
+		invalidFile    bool
+	}{
+		{
+			label:          "Domain Socket file",
+			listenOnSocket: true,
+			expectSocket:   true,
+			expectError:    false,
+		},
+		{
+			label:       "Non Existent file",
+			invalidFile: true,
+			expectError: true,
+		},
+		{
+			label:          "Regular file",
+			listenOnSocket: false,
+			expectSocket:   false,
+			expectError:    false,
+		},
+	}
+	for _, test := range tests {
+		f, err := os.CreateTemp("", "test-domain-socket")
+		require.NoErrorf(t, err, "Failed to create file for test purposes: %v while setting up: %s", err, test.label)
+		addr := f.Name()
+		f.Close()
+		var ln *net.UnixListener
+		if test.listenOnSocket {
+			os.Remove(addr)
+			ta, err := net.ResolveUnixAddr("unix", addr)
+			require.NoErrorf(t, err, "Failed to ResolveUnixAddr: %v while setting up: %s", err, test.label)
+			ln, err = net.ListenUnix("unix", ta)
+			require.NoErrorf(t, err, "Failed to ListenUnix: %v while setting up: %s", err, test.label)
+		}
+		fileToTest := addr
+		if test.invalidFile {
+			fileToTest = fileToTest + ".invalid"
+		}
+		result, err := IsUnixDomainSocket(fileToTest)
+		if test.listenOnSocket {
+			// this takes care of removing the file associated with the domain socket
+			ln.Close()
+		} else {
+			// explicitly remove regular file
+			os.Remove(addr)
+		}
+		if test.expectError {
+			assert.Errorf(t, err, "Unexpected nil error from IsUnixDomainSocket for %s", test.label)
+		} else {
+			assert.NoErrorf(t, err, "Unexpected error invoking IsUnixDomainSocket for %s", test.label)
+		}
+		assert.Equal(t, result, test.expectSocket, "Unexpected result from IsUnixDomainSocket: %v for %s", result, test.label)
+	}
+}

pkg/kubelet/util/util_unix_test.go

@@ -20,12 +20,9 @@ limitations under the License.
 package util
 
 import (
-	"net"
-	"os"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 func TestParseEndpoint(t *testing.T) {
@@ -74,66 +71,6 @@ func TestParseEndpoint(t *testing.T) {
 
 }
 
-func TestIsUnixDomainSocket(t *testing.T) {
-	tests := []struct {
-		label          string
-		listenOnSocket bool
-		expectSocket   bool
-		expectError    bool
-		invalidFile    bool
-	}{
-		{
-			label:          "Domain Socket file",
-			listenOnSocket: true,
-			expectSocket:   true,
-			expectError:    false,
-		},
-		{
-			label:       "Non Existent file",
-			invalidFile: true,
-			expectError: true,
-		},
-		{
-			label:          "Regular file",
-			listenOnSocket: false,
-			expectSocket:   false,
-			expectError:    false,
-		},
-	}
-	for _, test := range tests {
-		f, err := os.CreateTemp("", "test-domain-socket")
-		require.NoErrorf(t, err, "Failed to create file for test purposes: %v while setting up: %s", err, test.label)
-		addr := f.Name()
-		f.Close()
-		var ln *net.UnixListener
-		if test.listenOnSocket {
-			os.Remove(addr)
-			ta, err := net.ResolveUnixAddr("unix", addr)
-			require.NoErrorf(t, err, "Failed to ResolveUnixAddr: %v while setting up: %s", err, test.label)
-			ln, err = net.ListenUnix("unix", ta)
-			require.NoErrorf(t, err, "Failed to ListenUnix: %v while setting up: %s", err, test.label)
-		}
-		fileToTest := addr
-		if test.invalidFile {
-			fileToTest = fileToTest + ".invalid"
-		}
-		result, err := IsUnixDomainSocket(fileToTest)
-		if test.listenOnSocket {
-			// this takes care of removing the file associated with the domain socket
-			ln.Close()
-		} else {
-			// explicitly remove regular file
-			os.Remove(addr)
-		}
-		if test.expectError {
-			assert.NotNil(t, err, "Unexpected nil error from IsUnixDomainSocket for %s", test.label)
-		} else {
-			assert.Nil(t, err, "Unexpected error invoking IsUnixDomainSocket for %s", test.label)
-		}
-		assert.Equal(t, result, test.expectSocket, "Unexpected result from IsUnixDomainSocket: %v for %s", result, test.label)
-	}
-}
-
 func TestGetAddressAndDialer(t *testing.T) {
 	tests := []struct {
 		endpoint     string

pkg/kubelet/util/util_windows_test.go

@@ -22,8 +22,6 @@ package util
 import (
 	"fmt"
 	"math/rand"
-	"net"
-	"os"
 	"reflect"
 	"runtime"
 	"sync"
@@ -182,7 +180,7 @@ func TestParseEndpoint(t *testing.T) {
 
 }
 
-func testPipe(t *testing.T, label string) {
+func TestIsUnixDomainSocketPipe(t *testing.T) {
 	generatePipeName := func(suffixLen int) string {
 		rand.Seed(time.Now().UnixNano())
 		letter := []rune("abcdef0123456789")
@@ -196,52 +194,22 @@ func testPipe(t *testing.T, label string) {
 	pipeln, err := winio.ListenPipe(testFile, &winio.PipeConfig{SecurityDescriptor: "D:P(A;;GA;;;BA)(A;;GA;;;SY)"})
 	defer pipeln.Close()
 
-	require.NoErrorf(t, err, "Failed to listen on named pipe for test purposes: %v while setting up: %s", err, label)
+	require.NoErrorf(t, err, "Failed to listen on named pipe for test purposes: %v", err)
 	result, err := IsUnixDomainSocket(testFile)
-	assert.Nil(t, err, "Unexpected error: %v from IsUnixDomainSocket for %s", err, label)
+	assert.NoError(t, err, "Unexpected error from IsUnixDomainSocket.")
-	assert.False(t, result, "Unexpected result: true from IsUnixDomainSocket: %v for %s", result, label)
+	assert.False(t, result, "Unexpected result: true from IsUnixDomainSocket.")
-}
-
-func testRegularFile(t *testing.T, label string, exists bool) {
-	f, err := os.CreateTemp("", "test-file")
-	require.NoErrorf(t, err, "Failed to create file for test purposes: %v while setting up: %s", err, label)
-	testFile := f.Name()
-	if !exists {
-		testFile = testFile + ".absent"
-	}
-	f.Close()
-	result, err := IsUnixDomainSocket(testFile)
-	os.Remove(f.Name())
-	assert.Nil(t, err, "Unexpected error: %v from IsUnixDomainSocket for %s", err, label)
-	assert.False(t, result, "Unexpected result: true from IsUnixDomainSocket: %v for %s", result, label)
-}
-
-func testUnixDomainSocket(t *testing.T, label string) {
-	f, err := os.CreateTemp("", "test-domain-socket")
-	require.NoErrorf(t, err, "Failed to create file for test purposes: %v while setting up: %s", err, label)
-	testFile := f.Name()
-	f.Close()
-	os.Remove(testFile)
-	ta, err := net.ResolveUnixAddr("unix", testFile)
-	require.NoErrorf(t, err, "Failed to ResolveUnixAddr: %v while setting up: %s", err, label)
-	unixln, err := net.ListenUnix("unix", ta)
-	require.NoErrorf(t, err, "Failed to ListenUnix: %v while setting up: %s", err, label)
-	result, err := IsUnixDomainSocket(testFile)
-	unixln.Close()
-	assert.Nil(t, err, "Unexpected error: %v from IsUnixDomainSocket for %s", err, label)
-	assert.True(t, result, "Unexpected result: false from IsUnixDomainSocket: %v for %s", result, label)
 }
 
 // This is required as on Windows it's possible for the socket file backing a Unix domain socket to
 // exist but not be ready for socket communications yet as per
 // https://github.com/kubernetes/kubernetes/issues/104584
-func testPendingUnixDomainSocket(t *testing.T, label string) {
+func TestPendingUnixDomainSocket(t *testing.T) {
 	// Create a temporary file that will simulate the Unix domain socket file in a
 	// not-yet-ready state. We need this because the Kubelet keeps an eye on file
 	// changes and acts on them, leading to potential race issues as described in
 	// the referenced issue above
 	f, err := os.CreateTemp("", "test-domain-socket")
-	require.NoErrorf(t, err, "Failed to create file for test purposes: %v while setting up: %s", err, label)
+	require.NoErrorf(t, err, "Failed to create file for test purposes: %v", err)
 	testFile := f.Name()
 	f.Close()
 
@@ -250,8 +218,8 @@ func testPendingUnixDomainSocket(t *testing.T, label string) {
 	wg.Add(1)
 	go func() {
 		result, err := IsUnixDomainSocket(testFile)
-		assert.Nil(t, err, "Unexpected error: %v from IsUnixDomainSocket for %s", err, label)
+		assert.Nil(t, err, "Unexpected error from IsUnixDomainSocket: %v", err)
-		assert.True(t, result, "Unexpected result: false from IsUnixDomainSocket: %v for %s", result, label)
+		assert.True(t, result, "Unexpected result: false from IsUnixDomainSocket.")
 		wg.Done()
 	}()
 
@@ -261,23 +229,15 @@ func testPendingUnixDomainSocket(t *testing.T, label string) {
 	// Replace the temporary file with an actual Unix domain socket file
 	os.Remove(testFile)
 	ta, err := net.ResolveUnixAddr("unix", testFile)
-	require.NoErrorf(t, err, "Failed to ResolveUnixAddr: %v while setting up: %s", err, label)
+	require.NoError(t, err, "Failed to ResolveUnixAddr.")
 	unixln, err := net.ListenUnix("unix", ta)
-	require.NoErrorf(t, err, "Failed to ListenUnix: %v while setting up: %s", err, label)
+	require.NoError(t, err, "Failed to ListenUnix.")
 
 	// Wait for the goroutine to finish, then close the socket
 	wg.Wait()
 	unixln.Close()
 }
 
-func TestIsUnixDomainSocket(t *testing.T) {
-	testPipe(t, "Named Pipe")
-	testRegularFile(t, "Regular File that Exists", true)
-	testRegularFile(t, "Regular File that Does Not Exist", false)
-	testUnixDomainSocket(t, "Unix Domain Socket File")
-	testPendingUnixDomainSocket(t, "Pending Unix Domain Socket File")
-}
-
 func TestNormalizePath(t *testing.T) {
 	tests := []struct {
 		originalpath   string