runtimeclass-debugger/pkg/bridge/lookup_test.go

package bridge

import (
	"errors"
	"testing"
	"time"

	nodev1 "k8s.io/api/node/v1"
	apierrors "k8s.io/apimachinery/pkg/api/errors"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/runtime"
	kubefake "k8s.io/client-go/kubernetes/fake"
	ktesting "k8s.io/client-go/testing"
)

func runtimeClass(name, handler string) nodev1.RuntimeClass {
	return nodev1.RuntimeClass{
		ObjectMeta: metav1.ObjectMeta{Name: name},
		Handler:    handler,
	}
}

func TestNaiveLookupAlwaysNotFound(t *testing.T) {
	m, err := NewNaiveManager()
	if err != nil {
		t.Fatalf("NewNaiveManager: %v", err)
	}
	_, err = ResolveHandler(m, "kata")
	if !apierrors.IsNotFound(err) {
		t.Fatalf("expected NotFound for naive lookup, got %v", err)
	}
}

func TestLookupRules(t *testing.T) {
	m, err := NewWiredManager([]nodev1.RuntimeClass{
		runtimeClass("kata", "kata"),
		runtimeClass("runsc", "runsc"),
	})
	if err != nil {
		t.Fatalf("NewWiredManager: %v", err)
	}

	tests := []struct {
		name     string
		class    string
		handler  string
		notFound bool
	}{
		{name: "empty class name resolves to default handler", class: "", handler: ""},
		{name: "known class resolves to its handler", class: "kata", handler: "kata"},
		{name: "second known class resolves to its handler", class: "runsc", handler: "runsc"},
		{name: "unknown class returns NotFound", class: "nope", notFound: true},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			handler, err := ResolveHandler(m, tt.class)
			if tt.notFound {
				if !apierrors.IsNotFound(err) {
					t.Fatalf("expected NotFound, got handler %q err %v", handler, err)
				}
				return
			}
			if err != nil {
				t.Fatalf("unexpected error: %v", err)
			}
			if handler != tt.handler {
				t.Fatalf("expected handler %q, got %q", tt.handler, handler)
			}
		})
	}
}

func TestLookupWiredMissingClassNotFound(t *testing.T) {
	m, err := NewWiredManager(nil)
	if err != nil {
		t.Fatalf("NewWiredManager: %v", err)
	}
	_, err = ResolveHandler(m, "kata")
	if !apierrors.IsNotFound(err) {
		t.Fatalf("expected NotFound, got %v", err)
	}
}

func TestNewManagerForClientSyncError(t *testing.T) {
	fake := kubefake.NewSimpleClientset()
	fake.PrependReactor("list", "runtimeclasses", func(action ktesting.Action) (bool, runtime.Object, error) {
		return true, nil, errors.New("list exploded")
	})
	_, err := NewManagerForClientWithTimeout(fake, time.Second)
	if err == nil {
		t.Fatal("expected sync error, got nil")
	}
}