operator: add more tests for reconciler

Signed-off-by: Tuomas Katila <[email protected]>

Author: tkatila

pkg/controllers/reconciler_test.go

@@ -20,8 +20,367 @@ import (
 	"testing"
 
 	v1 "k8s.io/api/core/v1"
+
+	"errors"
+
+	apps "k8s.io/api/apps/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/types"
+	ctrl "sigs.k8s.io/controller-runtime"
+	"sigs.k8s.io/controller-runtime/pkg/client"
 )
 
+type mockPlugin struct {
+	client.Object
+}
+
+func (m *mockPlugin) GetNamespace() string {
+	return "default"
+}
+
+func (m *mockPlugin) GetObjectKind() schema.ObjectKind {
+	return &metav1.TypeMeta{
+		Kind:       "MockPlugin",
+		APIVersion: "v1",
+	}
+}
+
+func (m *mockPlugin) GetName() string {
+	return "mock"
+}
+
+func (m *mockPlugin) GetUID() types.UID {
+	return "mock-uid"
+}
+
+type mockController struct {
+	statusErr error
+	updated   bool
+	upgrade   bool
+}
+
+func (m *mockController) CreateEmptyObject() client.Object {
+	return &mockPlugin{}
+}
+
+func (m *mockController) NewDaemonSet(rawObj client.Object) *apps.DaemonSet {
+	return &apps.DaemonSet{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "mock-ds",
+			Namespace: "default",
+		},
+		Spec: apps.DaemonSetSpec{
+			Selector: &metav1.LabelSelector{
+				MatchLabels: map[string]string{"app": "mock"},
+			},
+			Template: v1.PodTemplateSpec{
+				ObjectMeta: metav1.ObjectMeta{
+					Labels: map[string]string{"app": "mock"},
+				},
+				Spec: v1.PodSpec{
+					Containers: []v1.Container{
+						{
+							Name:  "mock",
+							Image: "intel/intel-mock-plugin:latest",
+						},
+					},
+				},
+			},
+		},
+	}
+}
+
+func (m *mockController) UpdateDaemonSet(rawObj client.Object, ds *apps.DaemonSet) (updated bool) {
+	return m.updated
+}
+
+func (m *mockController) UpdateStatus(rawObj client.Object, ds *apps.DaemonSet, messages []string) (updated bool, err error) {
+	if m.statusErr != nil {
+		return false, m.statusErr
+	}
+
+	return true, nil
+}
+
+func (m *mockController) Upgrade(ctx context.Context, obj client.Object) bool {
+	return m.upgrade
+}
+
+type fakeStatusWriter struct{}
+
+func (f *fakeStatusWriter) Create(ctx context.Context, obj client.Object, obj2 client.Object, opts ...client.SubResourceCreateOption) error {
+	return nil
+}
+func (f *fakeStatusWriter) Update(ctx context.Context, obj client.Object, opts ...client.SubResourceUpdateOption) error {
+	return nil
+}
+func (f *fakeStatusWriter) Patch(ctx context.Context, obj client.Object, patch client.Patch, opts ...client.SubResourcePatchOption) error {
+	return nil
+}
+func (f *fakeStatusWriter) Status() client.StatusWriter {
+	return f
+}
+
+type fakeClient struct {
+	client.StatusWriter
+	client.Client
+	getErr       error
+	listErr      error
+	updateErr    error
+	createErr    error
+	statusErr    error
+	ds           []*apps.DaemonSet
+	pods         []*v1.Pod
+	createCalled bool
+}
+
+func (f *fakeClient) Get(ctx context.Context, key client.ObjectKey, obj client.Object, opts ...client.GetOption) error {
+	if f.getErr != nil {
+		return f.getErr
+	}
+
+	return nil
+}
+func (f *fakeClient) List(ctx context.Context, list client.ObjectList, opts ...client.ListOption) error {
+	if f.listErr != nil {
+		return f.listErr
+	}
+	switch l := list.(type) {
+	case *apps.DaemonSetList:
+		l.Items = []apps.DaemonSet{}
+
+		for _, ds := range f.ds {
+			l.Items = append(l.Items, *ds)
+		}
+	case *v1.PodList:
+		l.Items = []v1.Pod{}
+
+		for _, pod := range f.pods {
+			l.Items = append(l.Items, *pod)
+		}
+	}
+	return nil
+}
+func (f *fakeClient) Update(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error {
+	return f.updateErr
+}
+func (f *fakeClient) Create(ctx context.Context, obj client.Object, opts ...client.CreateOption) error {
+	f.createCalled = true
+	return f.createErr
+}
+func (f *fakeClient) Patch(ctx context.Context, obj client.Object, patch client.Patch, opts ...client.PatchOption) error {
+	return nil
+}
+func (f *fakeClient) Delete(ctx context.Context, obj client.Object, opts ...client.DeleteOption) error {
+	return nil
+}
+func (f *fakeClient) UpdateStatus(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error {
+	return f.statusErr
+}
+func (f *fakeClient) Status() client.StatusWriter {
+	return f.StatusWriter
+}
+func (f *fakeClient) Scheme() *runtime.Scheme {
+	s := runtime.NewScheme()
+	s.AddKnownTypeWithName(schema.GroupVersionKind{
+		Group:   "deviceplugin.intel.com",
+		Version: "v1",
+		Kind:    "MockPlugin",
+	}, &mockPlugin{})
+
+	return s
+}
+
+func fillDaemonSets() []*apps.DaemonSet {
+	return []*apps.DaemonSet{
+		{
+			ObjectMeta: metav1.ObjectMeta{
+				Name:      "mock-ds",
+				Namespace: "default",
+			},
+			Spec: apps.DaemonSetSpec{
+				Selector: &metav1.LabelSelector{
+					MatchLabels: map[string]string{"app": "mock"},
+				},
+				Template: v1.PodTemplateSpec{
+					ObjectMeta: metav1.ObjectMeta{
+						Labels: map[string]string{"app": "mock"},
+					},
+					Spec: v1.PodSpec{
+						Containers: []v1.Container{
+							{
+								Name:  "mock",
+								Image: "intel/intel-mock-plugin:latest",
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+}
+
+func fillPods() []*v1.Pod {
+	return []*v1.Pod{
+		{
+			ObjectMeta: metav1.ObjectMeta{
+				Name:      "mock-pod",
+				Namespace: "default",
+				OwnerReferences: []metav1.OwnerReference{
+					{
+						APIVersion: "apps/v1",
+						Kind:       "DaemonSet",
+						Name:       "mock-ds",
+						UID:        "mock-uid",
+					},
+				},
+			},
+			Spec: v1.PodSpec{
+				NodeName: "node1",
+				Containers: []v1.Container{
+					{
+						Name:  "mock",
+						Image: "intel/intel-mock-plugin:latest",
+					},
+				},
+			},
+		},
+	}
+}
+
+func TestReconciler_Reconcile_CreateDaemonSet(t *testing.T) {
+	controller := &mockController{}
+	c := &fakeClient{
+		StatusWriter: &fakeStatusWriter{},
+		ds:           []*apps.DaemonSet{},
+	}
+	r := &reconciler{
+		controller: controller,
+		Client:     c,
+		scheme:     c.Scheme(),
+		pluginKind: "MockPlugin",
+		ownerKey:   "owner",
+	}
+	req := ctrl.Request{NamespacedName: types.NamespacedName{Name: "mock", Namespace: "default"}}
+
+	res, err := r.Reconcile(context.Background(), req)
+	if err != nil {
+		t.Errorf("expected no error, got %v", err)
+	}
+	if res != (ctrl.Result{}) {
+		t.Errorf("expected empty result, got %v", res)
+	}
+	if c.createCalled == false {
+		t.Error("expected create to be called, but it was not")
+	}
+}
+
+func TestReconciler_Reconcile_UpdateDaemonSetAndStatus(t *testing.T) {
+	controller := &mockController{
+		updated: true,
+		upgrade: false,
+	}
+	c := &fakeClient{
+		StatusWriter: &fakeStatusWriter{},
+		ds:           fillDaemonSets(),
+		pods:         fillPods(),
+	}
+	r := &reconciler{
+		controller: controller,
+		Client:     c,
+		scheme:     c.Scheme(),
+		pluginKind: "MockPlugin",
+		ownerKey:   "owner",
+	}
+	req := ctrl.Request{NamespacedName: client.ObjectKey{Name: "mock", Namespace: "default"}}
+
+	res, err := r.Reconcile(context.Background(), req)
+	if err != nil {
+		t.Errorf("expected no error, got %v", err)
+	}
+	if res != (ctrl.Result{}) {
+		t.Errorf("expected empty result, got %v", res)
+	}
+}
+
+type getError struct {
+	error
+}
+type listError struct {
+	error
+}
+type updatestatusError struct {
+	error
+}
+
+func TestReconciler_Reconcile_GetError(t *testing.T) {
+	controller := &mockController{}
+	c := &fakeClient{
+		getErr:       getError{},
+		StatusWriter: &fakeStatusWriter{},
+	}
+	r := &reconciler{
+		controller: controller,
+		Client:     c,
+		scheme:     c.Scheme(),
+		pluginKind: "MockPlugin",
+		ownerKey:   "owner",
+	}
+	req := ctrl.Request{NamespacedName: client.ObjectKey{Name: "mock", Namespace: "default"}}
+
+	_, err := r.Reconcile(context.Background(), req)
+	if err == nil || errors.Is(err, c.getErr) == false {
+		t.Errorf("expected get error, got %v", err)
+	}
+}
+
+func TestReconciler_Reconcile_ListError(t *testing.T) {
+	controller := &mockController{}
+	c := &fakeClient{
+		listErr:      listError{},
+		StatusWriter: &fakeStatusWriter{},
+	}
+	r := &reconciler{
+		controller: controller,
+		Client:     c,
+		scheme:     c.Scheme(),
+		pluginKind: "MockPlugin",
+		ownerKey:   "owner",
+	}
+	req := ctrl.Request{NamespacedName: client.ObjectKey{Name: "mock", Namespace: "default"}}
+
+	_, err := r.Reconcile(context.Background(), req)
+	if err == nil || errors.Is(err, c.listErr) == false {
+		t.Errorf("expected list error, got %v", err)
+	}
+}
+
+func TestReconciler_Reconcile_UpdateStatusError(t *testing.T) {
+	controller := &mockController{
+		statusErr: updatestatusError{},
+	}
+	c := &fakeClient{
+		StatusWriter: &fakeStatusWriter{},
+		ds:           fillDaemonSets(),
+		pods:         fillPods(),
+	}
+	r := &reconciler{
+		controller: controller,
+		Client:     c,
+		scheme:     c.Scheme(),
+		pluginKind: "MockPlugin",
+		ownerKey:   "owner",
+	}
+	req := ctrl.Request{NamespacedName: client.ObjectKey{Name: "mock", Namespace: "default"}}
+
+	_, err := r.Reconcile(context.Background(), req)
+	if err == nil || errors.Is(err, controller.statusErr) == false {
+		t.Errorf("expected status update error, got %v", err)
+	}
+}
+
 func TestUpgrade(test *testing.T) {
 	image := "intel/intel-dsa-plugin"
 	initimage := "intel/intel-idxd-config-initcontainer"