github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-07-23 03:41:45 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #110949 from claudiubelu/adds-unittests-4

Browse Source 
tests: Ports kubelet unit tests to Windows
This commit is contained in:
Kubernetes Prow Robot 2023-03-09 21:32:30 -08:00 committed by GitHub
commit 15f5a5c6ef
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 73 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

63
pkg/kubelet/util/util_test.go
View File

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

63
pkg/kubelet/util/util_unix_test.go
View File

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

60
pkg/kubelet/util/util_windows_test.go
View File

@ -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.False(t, result, "Unexpected result: true from IsUnixDomainSocket: %v for %s", result, label)
}
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)
assert.NoError(t, err, "Unexpected error from IsUnixDomainSocket.")
assert.False(t, result, "Unexpected result: true from IsUnixDomainSocket.")
}
// 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.True(t, result, "Unexpected result: false from IsUnixDomainSocket: %v for %s", result, label)
assert.Nil(t, err, "Unexpected error from IsUnixDomainSocket: %v", err)
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