mirror of
https://github.com/kubevirt/containerized-data-importer.git
synced 2025-06-03 06:30:22 +00:00
9468ba94c7
Note we are intentionally skipping test files for now, golint pkg/controller... will skip them, so I'll skip them to.
393 lines
13 KiB
Go
393 lines
13 KiB
Go
package controller
|
|
|
|
import (
|
|
"fmt"
|
|
"reflect"
|
|
"testing"
|
|
|
|
corev1 "k8s.io/api/core/v1"
|
|
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
|
"k8s.io/apimachinery/pkg/runtime"
|
|
"k8s.io/apimachinery/pkg/runtime/schema"
|
|
"k8s.io/apimachinery/pkg/util/diff"
|
|
kubeinformers "k8s.io/client-go/informers"
|
|
k8sfake "k8s.io/client-go/kubernetes/fake"
|
|
core "k8s.io/client-go/testing"
|
|
"k8s.io/client-go/tools/cache"
|
|
. "kubevirt.io/containerized-data-importer/pkg/common"
|
|
)
|
|
|
|
type cloneFixture struct {
|
|
t *testing.T
|
|
|
|
kubeclient *k8sfake.Clientset
|
|
|
|
// Objects to put in the store.
|
|
pvcLister []*corev1.PersistentVolumeClaim
|
|
podLister []*corev1.Pod
|
|
|
|
// Actions expected to happen on the client.
|
|
kubeactions []core.Action
|
|
actions []core.Action
|
|
|
|
// Objects from here preloaded into NewSimpleFake.
|
|
kubeobjects []runtime.Object
|
|
}
|
|
|
|
func newCloneFixture(t *testing.T) *cloneFixture {
|
|
f := &cloneFixture{}
|
|
f.t = t
|
|
f.kubeobjects = []runtime.Object{}
|
|
return f
|
|
}
|
|
|
|
func (f *cloneFixture) newController() *CloneController {
|
|
|
|
f.kubeclient = k8sfake.NewSimpleClientset(f.kubeobjects...)
|
|
|
|
podFactory := kubeinformers.NewSharedInformerFactory(f.kubeclient, noResyncPeriodFunc())
|
|
pvcFactory := kubeinformers.NewSharedInformerFactory(f.kubeclient, noResyncPeriodFunc())
|
|
|
|
podInformer := podFactory.Core().V1().Pods()
|
|
pvcInformer := pvcFactory.Core().V1().PersistentVolumeClaims()
|
|
|
|
c := NewCloneController(f.kubeclient,
|
|
pvcInformer,
|
|
podInformer,
|
|
"test/mycloneimage",
|
|
"Always",
|
|
"5")
|
|
|
|
for _, pod := range f.podLister {
|
|
c.podInformer.GetIndexer().Add(pod)
|
|
}
|
|
|
|
for _, pvc := range f.pvcLister {
|
|
c.pvcInformer.GetIndexer().Add(pvc)
|
|
}
|
|
|
|
return c
|
|
}
|
|
|
|
func (f *cloneFixture) run(pvcName string) {
|
|
f.runController(pvcName, true, false, false)
|
|
}
|
|
|
|
func (f *cloneFixture) runWithExpectation(pvcName string) {
|
|
f.runController(pvcName, true, false, true)
|
|
}
|
|
|
|
func (f *cloneFixture) runExpectError(pvcName string) {
|
|
f.runController(pvcName, true, true, false)
|
|
}
|
|
|
|
func (f *cloneFixture) runController(pvcName string,
|
|
startInformers bool,
|
|
expectError bool,
|
|
withCreateExpectation bool) {
|
|
c := f.newController()
|
|
if startInformers {
|
|
stopCh := make(chan struct{})
|
|
defer close(stopCh)
|
|
go c.pvcInformer.Run(stopCh)
|
|
go c.podInformer.Run(stopCh)
|
|
cache.WaitForCacheSync(stopCh, c.pvcInformer.HasSynced)
|
|
cache.WaitForCacheSync(stopCh, c.pvcInformer.HasSynced)
|
|
}
|
|
|
|
if withCreateExpectation {
|
|
c.expectPodCreate(pvcName)
|
|
}
|
|
err := c.syncPvc(pvcName)
|
|
if !expectError && err != nil {
|
|
f.t.Errorf("error syncing pvc: %s: %v", pvcName, err)
|
|
} else if expectError && err == nil {
|
|
f.t.Error("expected error syncing pvc, got nil")
|
|
}
|
|
|
|
k8sActions := filterCloneActions(f.kubeclient.Actions())
|
|
for i, action := range k8sActions {
|
|
if len(f.kubeactions) < i+1 {
|
|
f.t.Errorf("%d unexpected actions: %+v", len(k8sActions)-len(f.kubeactions), k8sActions[i:])
|
|
break
|
|
}
|
|
|
|
expectedAction := f.kubeactions[i]
|
|
checkCloneAction(expectedAction, action, f.t)
|
|
}
|
|
|
|
if len(f.kubeactions) > len(k8sActions) {
|
|
f.t.Errorf("%d additional expected actions:%+v", len(f.kubeactions)-len(k8sActions), f.kubeactions[len(k8sActions):])
|
|
}
|
|
}
|
|
|
|
// checkCloneAction verifies that expected and actual actions are equal and both have
|
|
// same attached resources
|
|
func checkCloneAction(expected, actual core.Action, t *testing.T) {
|
|
if !(expected.Matches(actual.GetVerb(), actual.GetResource().Resource) && actual.GetSubresource() == expected.GetSubresource()) {
|
|
t.Errorf("Expected\n\t%#v\ngot\n\t%#v", expected, actual)
|
|
return
|
|
}
|
|
|
|
if reflect.TypeOf(actual) != reflect.TypeOf(expected) {
|
|
t.Errorf("Action has wrong type. Expected: %t. Got: %t", expected, actual)
|
|
return
|
|
}
|
|
|
|
switch a := actual.(type) {
|
|
case core.CreateAction:
|
|
e, _ := expected.(core.CreateAction)
|
|
expObject := e.GetObject()
|
|
object := a.GetObject()
|
|
|
|
if !reflect.DeepEqual(expObject, object) {
|
|
t.Errorf("Action %s %s has wrong object\nDiff:\n %s",
|
|
a.GetVerb(), a.GetResource().Resource, diff.ObjectGoPrintDiff(expObject, object))
|
|
}
|
|
case core.UpdateAction:
|
|
e, _ := expected.(core.UpdateAction)
|
|
expObject := e.GetObject()
|
|
object := a.GetObject()
|
|
|
|
if !reflect.DeepEqual(expObject, object) {
|
|
t.Errorf("Action %s %s has wrong object\nDiff:\n %s",
|
|
a.GetVerb(), a.GetResource().Resource, diff.ObjectGoPrintDiff(expObject, object))
|
|
}
|
|
case core.PatchAction:
|
|
e, _ := expected.(core.PatchAction)
|
|
expPatch := e.GetPatch()
|
|
patch := a.GetPatch()
|
|
|
|
if !reflect.DeepEqual(expPatch, expPatch) {
|
|
t.Errorf("Action %s %s has wrong patch\nDiff:\n %s",
|
|
a.GetVerb(), a.GetResource().Resource, diff.ObjectGoPrintDiff(expPatch, patch))
|
|
}
|
|
}
|
|
}
|
|
|
|
// filterCloneActions filters list and watch actions for testing resources.
|
|
// Since list and watch don't change resource state we can filter it to lower
|
|
// nose level in our tests.
|
|
func filterCloneActions(actions []core.Action) []core.Action {
|
|
ret := []core.Action{}
|
|
for _, action := range actions {
|
|
if len(action.GetNamespace()) == 0 &&
|
|
(action.Matches("list", "persistentvolumeclaims") ||
|
|
action.Matches("watch", "persistentvolumeclaims") ||
|
|
action.Matches("list", "pods") ||
|
|
action.Matches("watch", "pods")) {
|
|
continue
|
|
}
|
|
ret = append(ret, action)
|
|
}
|
|
|
|
return ret
|
|
}
|
|
|
|
func (f *cloneFixture) expectCreatePodAction(d *corev1.Pod) {
|
|
f.kubeactions = append(f.kubeactions, core.NewCreateAction(schema.GroupVersionResource{Resource: "pods", Version: "v1"}, d.Namespace, d))
|
|
}
|
|
|
|
func (f *cloneFixture) expectUpdatePvcAction(d *corev1.PersistentVolumeClaim) {
|
|
f.kubeactions = append(f.kubeactions, core.NewUpdateAction(schema.GroupVersionResource{Resource: "persistentvolumeclaims", Version: "v1"}, d.Namespace, d))
|
|
}
|
|
|
|
// Verifies basic pods creation when new PVC is discovered
|
|
func TestCreatesClonePods(t *testing.T) {
|
|
f := newCloneFixture(t)
|
|
pvc := createClonePvc("target-pvc", "target-ns", map[string]string{AnnCloneRequest: "source-ns/golden-pvc"}, nil)
|
|
|
|
f.pvcLister = append(f.pvcLister, pvc)
|
|
f.kubeobjects = append(f.kubeobjects, pvc)
|
|
id := string(pvc.GetUID())
|
|
expSourcePod := createSourcePod(pvc, DataVolName, id)
|
|
f.expectCreatePodAction(expSourcePod)
|
|
expTargetPod := createTargetPod(pvc, DataVolName, id, "source-ns")
|
|
f.expectCreatePodAction(expTargetPod)
|
|
|
|
f.run(getPvcKey(pvc, t))
|
|
}
|
|
|
|
// Verifies pods creation is observed and pvc labels are set.
|
|
func TestCloneObservePod(t *testing.T) {
|
|
f := newCloneFixture(t)
|
|
pvc := createPvc("trget-pvc", "target-ns", map[string]string{AnnCloneRequest: "source-ns/golden-pvc"}, nil)
|
|
id := string(pvc.GetUID())
|
|
|
|
sourcePod := createSourcePod(pvc, DataVolName, id)
|
|
sourcePod.Name = "madeup-source-name"
|
|
sourcePod.Status.Phase = corev1.PodPending
|
|
sourcePod.Namespace = "source-ns"
|
|
|
|
targetPod := createTargetPod(pvc, DataVolName, id, sourcePod.Namespace)
|
|
targetPod.Name = "madeup-target-name"
|
|
targetPod.Status.Phase = corev1.PodPending
|
|
targetPod.Namespace = "target-ns"
|
|
|
|
f.pvcLister = append(f.pvcLister, pvc)
|
|
f.podLister = append(f.podLister, sourcePod)
|
|
f.podLister = append(f.podLister, targetPod)
|
|
f.kubeobjects = append(f.kubeobjects, pvc)
|
|
f.kubeobjects = append(f.kubeobjects, sourcePod)
|
|
f.kubeobjects = append(f.kubeobjects, targetPod)
|
|
|
|
expPvc := pvc.DeepCopy()
|
|
expPvc.ObjectMeta.Labels = map[string]string{CDI_LABEL_KEY: CDI_LABEL_VALUE}
|
|
expPvc.ObjectMeta.Annotations = map[string]string{AnnClonePodPhase: string(corev1.PodPending), AnnCloneRequest: "source-ns/golden-pvc"}
|
|
|
|
f.expectUpdatePvcAction(expPvc)
|
|
|
|
f.run(getPvcKey(pvc, t))
|
|
}
|
|
|
|
// Verifies pods status updates are reflected in PVC annotations
|
|
func TestClonePodStatusUpdating(t *testing.T) {
|
|
f := newCloneFixture(t)
|
|
pvc := createPvc("target-pvc", "target-ns", map[string]string{AnnCloneRequest: "source-ns/golden-pvc"}, nil)
|
|
id := string(pvc.GetUID())
|
|
sourcePod := createSourcePod(pvc, DataVolName, id)
|
|
sourcePod.Name = "madeup-source-name"
|
|
sourcePod.Status.Phase = corev1.PodRunning
|
|
sourcePod.Namespace = "source-ns"
|
|
|
|
targetPod := createTargetPod(pvc, DataVolName, id, sourcePod.Namespace)
|
|
targetPod.Name = "madeup-target-name"
|
|
targetPod.Status.Phase = corev1.PodRunning
|
|
targetPod.Namespace = "target-ns"
|
|
|
|
pvc.ObjectMeta.Annotations = map[string]string{AnnClonePodPhase: string(corev1.PodPending), AnnCloneRequest: "source-ns/golden-pvc"}
|
|
pvc.ObjectMeta.Labels = map[string]string{CDI_LABEL_KEY: CDI_LABEL_VALUE}
|
|
|
|
f.pvcLister = append(f.pvcLister, pvc)
|
|
f.podLister = append(f.podLister, sourcePod)
|
|
f.podLister = append(f.podLister, targetPod)
|
|
f.kubeobjects = append(f.kubeobjects, pvc)
|
|
f.kubeobjects = append(f.kubeobjects, sourcePod)
|
|
f.kubeobjects = append(f.kubeobjects, targetPod)
|
|
|
|
// expecting pvc's pod status annotation to be updated from pending => running
|
|
expPvc := pvc.DeepCopy()
|
|
expPvc.ObjectMeta.Annotations = map[string]string{AnnClonePodPhase: string(targetPod.Status.Phase), AnnCloneRequest: "source-ns/golden-pvc"}
|
|
|
|
f.expectUpdatePvcAction(expPvc)
|
|
|
|
f.run(getPvcKey(pvc, t))
|
|
}
|
|
|
|
// verifies no work is done on pvcs without our annotations
|
|
func TestCloneIgnorePVC(t *testing.T) {
|
|
f := newCloneFixture(t)
|
|
pvc := createPvc("target-pvc", "target-ns", nil, nil)
|
|
|
|
f.pvcLister = append(f.pvcLister, pvc)
|
|
f.kubeobjects = append(f.kubeobjects, pvc)
|
|
|
|
f.runWithExpectation(getPvcKey(pvc, t))
|
|
}
|
|
|
|
// verify error if ownership doesn't match
|
|
func TestCloneOwnership(t *testing.T) {
|
|
f := newCloneFixture(t)
|
|
pvc := createPvc("testPvc1", "default", map[string]string{AnnCloneRequest: "source-ns/golden-pvc"}, nil)
|
|
id := string(pvc.GetUID())
|
|
sourcePod := createSourcePod(pvc, DataVolName, id)
|
|
sourcePod.Name = "madeup-source-name"
|
|
sourcePod.Status.Phase = corev1.PodPending
|
|
sourcePod.Namespace, _ = ParseSourcePvcAnnotation(pvc.GetAnnotations()[AnnCloneRequest], "/")
|
|
sourcePod.ObjectMeta.OwnerReferences = []metav1.OwnerReference{}
|
|
|
|
targetPod := createTargetPod(pvc, DataVolName, id, sourcePod.Namespace)
|
|
targetPod.Status.Phase = corev1.PodPending
|
|
targetPod.Namespace = pvc.Namespace
|
|
targetPod.ObjectMeta.OwnerReferences = []metav1.OwnerReference{}
|
|
|
|
f.pvcLister = append(f.pvcLister, pvc)
|
|
f.podLister = append(f.podLister, sourcePod)
|
|
f.podLister = append(f.podLister, targetPod)
|
|
f.kubeobjects = append(f.kubeobjects, pvc)
|
|
f.kubeobjects = append(f.kubeobjects, sourcePod)
|
|
f.kubeobjects = append(f.kubeobjects, targetPod)
|
|
|
|
f.runExpectError(getPvcKey(pvc, t))
|
|
}
|
|
|
|
func TestCloneFindPodsInCacheUpdating(t *testing.T) {
|
|
|
|
f := newCloneFixture(t)
|
|
|
|
tests := []struct {
|
|
pvc *corev1.PersistentVolumeClaim
|
|
sourcePod *corev1.Pod
|
|
targetPod *corev1.Pod
|
|
}{
|
|
{
|
|
pvc: createPvc("target-pvc", "target-ns", map[string]string{AnnCloneRequest: "source-ns/golden-pvc"}, nil),
|
|
},
|
|
{
|
|
pvc: createPvc("target-pvc2", "target2-ns", map[string]string{AnnCloneRequest: "source-ns/golden-pvc"}, nil),
|
|
},
|
|
}
|
|
|
|
id := string(tests[0].pvc.GetUID())
|
|
tests[0].sourcePod = createSourcePod(tests[0].pvc, DataVolName, id)
|
|
tests[0].sourcePod.Namespace = "source-ns"
|
|
tests[0].sourcePod.Name = fmt.Sprintf("fakesourcename%d", 1)
|
|
|
|
tests[0].targetPod = createTargetPod(tests[0].pvc, DataVolName, id, tests[0].sourcePod.Namespace)
|
|
tests[0].targetPod.Namespace = "target-ns"
|
|
tests[0].sourcePod.Name = fmt.Sprintf("faketargetname%d", 1)
|
|
|
|
f.pvcLister = append(f.pvcLister, tests[0].pvc)
|
|
f.podLister = append(f.podLister, tests[0].sourcePod)
|
|
f.podLister = append(f.podLister, tests[0].targetPod)
|
|
|
|
f.kubeobjects = append(f.kubeobjects, tests[0].pvc)
|
|
f.kubeobjects = append(f.kubeobjects, tests[0].sourcePod)
|
|
f.kubeobjects = append(f.kubeobjects, tests[0].targetPod)
|
|
|
|
tests[1].sourcePod = createSourcePod(tests[1].pvc, DataVolName, id)
|
|
tests[1].sourcePod.Namespace = "source-ns"
|
|
tests[1].sourcePod.Name = fmt.Sprintf("fakesourcename%d", 2)
|
|
|
|
tests[1].targetPod = createTargetPod(tests[1].pvc, DataVolName, id, tests[1].sourcePod.Namespace)
|
|
tests[1].targetPod.Namespace = "target2-ns"
|
|
tests[1].sourcePod.Name = fmt.Sprintf("faketargetname%d", 2)
|
|
|
|
f.pvcLister = append(f.pvcLister, tests[1].pvc)
|
|
f.podLister = append(f.podLister, tests[1].sourcePod)
|
|
f.podLister = append(f.podLister, tests[1].targetPod)
|
|
|
|
f.kubeobjects = append(f.kubeobjects, tests[1].pvc)
|
|
f.kubeobjects = append(f.kubeobjects, tests[1].sourcePod)
|
|
f.kubeobjects = append(f.kubeobjects, tests[1].targetPod)
|
|
|
|
controller := f.newController()
|
|
|
|
stopCh := make(chan struct{})
|
|
defer close(stopCh)
|
|
go controller.pvcInformer.Run(stopCh)
|
|
go controller.podInformer.Run(stopCh)
|
|
cache.WaitForCacheSync(stopCh, controller.pvcInformer.HasSynced)
|
|
cache.WaitForCacheSync(stopCh, controller.pvcInformer.HasSynced)
|
|
|
|
for _, test := range tests {
|
|
foundSourcePod, foundTargetPod, err := controller.findClonePodsFromCache(test.pvc)
|
|
if err != nil {
|
|
t.Errorf("unexpected error: %v", err)
|
|
}
|
|
|
|
if foundSourcePod == nil {
|
|
t.Errorf("didn't find source pod for pvc %v", test.pvc)
|
|
}
|
|
if !reflect.DeepEqual(foundSourcePod, test.sourcePod) {
|
|
t.Errorf("wrong source pod found.\nfound %v\nwant %v", foundSourcePod, test.sourcePod)
|
|
}
|
|
if foundTargetPod == nil {
|
|
t.Errorf("didn't find target pod for pvc %v", test.pvc)
|
|
}
|
|
if !reflect.DeepEqual(foundSourcePod, test.sourcePod) {
|
|
t.Errorf("wrong source pod found.\nfound %v\nwant %v", foundSourcePod, test.sourcePod)
|
|
}
|
|
}
|
|
}
|