package client_test

import (

"context"

"fmt"

"sync/atomic"

. "github.com/onsi/ginkgo"

. "github.com/onsi/gomega"

appsv1 "k8s.io/api/apps/v1"

corev1 "k8s.io/api/core/v1"

metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"

"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"

"k8s.io/apimachinery/pkg/fields"

"k8s.io/apimachinery/pkg/runtime/schema"

"k8s.io/apimachinery/pkg/watch"

"sigs.k8s.io/controller-runtime/pkg/client"

)

var _ = Describe("ClientWithWatch", func() {

var dep *appsv1.Deployment

var count uint64 = 0

var replicaCount int32 = 2

var ns = "kube-public"

ctx := context.TODO()

BeforeEach(func() {

atomic.AddUint64(&count, 1)

dep = &appsv1.Deployment{

ObjectMeta: metav1.ObjectMeta{Name: fmt.Sprintf("watch-deployment-name-%v", count), Namespace: ns, Labels: map[string]string{"app": fmt.Sprintf("bar-%v", count)}},

Spec: appsv1.DeploymentSpec{

Replicas: &replicaCount,

Selector: &metav1.LabelSelector{

MatchLabels: map[string]string{"foo": "bar"},

},

Template: corev1.PodTemplateSpec{

ObjectMeta: metav1.ObjectMeta{Labels: map[string]string{"foo": "bar"}},

Spec: corev1.PodSpec{Containers: []corev1.Container{{Name: "nginx", Image: "nginx"}}},

},

},

}

var err error

dep, err = clientset.AppsV1().Deployments(ns).Create(ctx, dep, metav1.CreateOptions{})

Expect(err).NotTo(HaveOccurred())

}, serverSideTimeoutSeconds)

AfterEach(func() {

deleteDeployment(ctx, dep, ns)

}, serverSideTimeoutSeconds)

Describe("NewWithWatch", func() {

It("should return a new Client", func() {

cl, err := client.NewWithWatch(cfg, client.Options{})

Expect(err).NotTo(HaveOccurred())

Expect(cl).NotTo(BeNil())

})

watchSuite := func(through client.ObjectList, expectedType client.Object) {

cl, err := client.NewWithWatch(cfg, client.Options{})

Expect(err).NotTo(HaveOccurred())

Expect(cl).NotTo(BeNil())

watchInterface, err := cl.Watch(ctx, through, &client.ListOptions{

FieldSelector: fields.OneTermEqualSelector("metadata.name", dep.Name),

Namespace: dep.Namespace,

})

Expect(err).NotTo(HaveOccurred())

Expect(watchInterface).NotTo(BeNil())

defer watchInterface.Stop()

event, ok := <-watchInterface.ResultChan()

Expect(ok).To(BeTrue())

Expect(event.Type).To(BeIdenticalTo(watch.Added))

Expect(event.Object).To(BeAssignableToTypeOf(expectedType))

// The metadata client doesn't set GVK so we just use the

// name and UID as a proxy to confirm that we got the right

// object.

metaObject, ok := event.Object.(metav1.Object)

Expect(ok).To(BeTrue())

Expect(metaObject.GetName()).To(Equal(dep.Name))

Expect(metaObject.GetUID()).To(Equal(dep.UID))

}

It("should receive a create event when watching the typed object", func() {

watchSuite(&appsv1.DeploymentList{}, &appsv1.Deployment{})

}, 15)

It("should receive a create event when watching the unstructured object", func() {

u := &unstructured.UnstructuredList{}

u.SetGroupVersionKind(schema.GroupVersionKind{

Group: "apps",

Kind: "Deployment",

Version: "v1",

})

watchSuite(u, &unstructured.Unstructured{})

}, 15)

It("should receive a create event when watching the metadata object", func() {

m := &metav1.PartialObjectMetadataList{TypeMeta: metav1.TypeMeta{Kind: "Deployment", APIVersion: "apps/v1"}}

watchSuite(m, &metav1.PartialObjectMetadata{})

}, 15)

})

})