github.com/argoproj/argo-events@v1.9.1/webhook/validator/validator_test.go (about)

     1  package validator
     2  
     3  import (
     4  	"context"
     5  	"encoding/json"
     6  	"testing"
     7  
     8  	"github.com/stretchr/testify/assert"
     9  	corev1 "k8s.io/api/core/v1"
    10  	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    11  	"k8s.io/apimachinery/pkg/runtime/schema"
    12  	fakeClient "k8s.io/client-go/kubernetes/fake"
    13  
    14  	"github.com/argoproj/argo-events/common"
    15  	"github.com/argoproj/argo-events/common/logging"
    16  	eventbusv1alpha1 "github.com/argoproj/argo-events/pkg/apis/eventbus/v1alpha1"
    17  	eventsourcev1alpha1 "github.com/argoproj/argo-events/pkg/apis/eventsource/v1alpha1"
    18  	sensorv1alpha1 "github.com/argoproj/argo-events/pkg/apis/sensor/v1alpha1"
    19  	fakeeventbusclient "github.com/argoproj/argo-events/pkg/client/eventbus/clientset/versioned/fake"
    20  	fakeeventsourceclient "github.com/argoproj/argo-events/pkg/client/eventsource/clientset/versioned/fake"
    21  	fakesensorclient "github.com/argoproj/argo-events/pkg/client/sensor/clientset/versioned/fake"
    22  )
    23  
    24  const (
    25  	testNamespace = "test-ns"
    26  )
    27  
    28  var (
    29  	fakeK8sClient         = fakeClient.NewSimpleClientset()
    30  	fakeEventBusClient    = fakeeventbusclient.NewSimpleClientset()
    31  	fakeEventSourceClient = fakeeventsourceclient.NewSimpleClientset()
    32  	fakeSensorClient      = fakesensorclient.NewSimpleClientset()
    33  )
    34  
    35  func contextWithLogger(t *testing.T) context.Context {
    36  	t.Helper()
    37  	return logging.WithLogger(context.Background(), logging.NewArgoEventsLogger())
    38  }
    39  
    40  func fromSchemaGVK(gvk schema.GroupVersionKind) metav1.GroupVersionKind {
    41  	return metav1.GroupVersionKind{
    42  		Group:   gvk.Group,
    43  		Version: gvk.Version,
    44  		Kind:    gvk.Kind,
    45  	}
    46  }
    47  
    48  func fakeEventBus() *eventbusv1alpha1.EventBus {
    49  	return &eventbusv1alpha1.EventBus{
    50  		TypeMeta: metav1.TypeMeta{
    51  			APIVersion: eventbusv1alpha1.SchemeGroupVersion.String(),
    52  			Kind:       "EventBus",
    53  		},
    54  		ObjectMeta: metav1.ObjectMeta{
    55  			Namespace: testNamespace,
    56  			Name:      common.DefaultEventBusName,
    57  		},
    58  		Spec: eventbusv1alpha1.EventBusSpec{
    59  			NATS: &eventbusv1alpha1.NATSBus{
    60  				Native: &eventbusv1alpha1.NativeStrategy{
    61  					Auth: &eventbusv1alpha1.AuthStrategyToken,
    62  				},
    63  			},
    64  		},
    65  	}
    66  }
    67  
    68  func fakeExoticEventBus() *eventbusv1alpha1.EventBus {
    69  	cID := "test-cluster-id"
    70  	return &eventbusv1alpha1.EventBus{
    71  		TypeMeta: metav1.TypeMeta{
    72  			APIVersion: eventbusv1alpha1.SchemeGroupVersion.String(),
    73  			Kind:       "EventBus",
    74  		},
    75  		ObjectMeta: metav1.ObjectMeta{
    76  			Namespace: testNamespace,
    77  			Name:      "test-name",
    78  		},
    79  		Spec: eventbusv1alpha1.EventBusSpec{
    80  			NATS: &eventbusv1alpha1.NATSBus{
    81  				Exotic: &eventbusv1alpha1.NATSConfig{
    82  					ClusterID: &cID,
    83  					URL:       "nats://adsaf:1234",
    84  				},
    85  			},
    86  		},
    87  	}
    88  }
    89  
    90  func fakeSensor() *sensorv1alpha1.Sensor {
    91  	return &sensorv1alpha1.Sensor{
    92  		ObjectMeta: metav1.ObjectMeta{
    93  			Name:      "test-sensor",
    94  			Namespace: testNamespace,
    95  		},
    96  		Spec: sensorv1alpha1.SensorSpec{
    97  			Template: &sensorv1alpha1.Template{
    98  				ServiceAccountName: "fake-sa",
    99  				ImagePullSecrets: []corev1.LocalObjectReference{
   100  					{
   101  						Name: "test",
   102  					},
   103  				},
   104  				Container: &corev1.Container{
   105  					VolumeMounts: []corev1.VolumeMount{
   106  						{
   107  							MountPath: "/test-data",
   108  							Name:      "test-data",
   109  						},
   110  					},
   111  				},
   112  				Volumes: []corev1.Volume{
   113  					{
   114  						Name: "test-data",
   115  						VolumeSource: corev1.VolumeSource{
   116  							EmptyDir: &corev1.EmptyDirVolumeSource{},
   117  						},
   118  					},
   119  				},
   120  			},
   121  			Triggers: []sensorv1alpha1.Trigger{
   122  				{
   123  					Template: &sensorv1alpha1.TriggerTemplate{
   124  						Name: "fake-trigger",
   125  						K8s: &sensorv1alpha1.StandardK8STrigger{
   126  							Operation: "create",
   127  							Source:    &sensorv1alpha1.ArtifactLocation{},
   128  						},
   129  					},
   130  				},
   131  			},
   132  			Dependencies: []sensorv1alpha1.EventDependency{
   133  				{
   134  					Name:            "fake-dep",
   135  					EventSourceName: "fake-source",
   136  					EventName:       "fake-one",
   137  				},
   138  			},
   139  		},
   140  	}
   141  }
   142  
   143  func fakeCalendarEventSourceMap(name string) map[string]eventsourcev1alpha1.CalendarEventSource {
   144  	return map[string]eventsourcev1alpha1.CalendarEventSource{name: {Schedule: "*/5 * * * *"}}
   145  }
   146  
   147  func fakeCalendarEventSource() *eventsourcev1alpha1.EventSource {
   148  	return &eventsourcev1alpha1.EventSource{
   149  		ObjectMeta: metav1.ObjectMeta{
   150  			Namespace: testNamespace,
   151  			Name:      "test-es",
   152  		},
   153  		Spec: eventsourcev1alpha1.EventSourceSpec{
   154  			Calendar: fakeCalendarEventSourceMap("test"),
   155  		},
   156  	}
   157  }
   158  
   159  func TestGetValidator(t *testing.T) {
   160  	t.Run("test get EventBus validator", func(t *testing.T) {
   161  		byts, err := json.Marshal(fakeEventBus())
   162  		assert.NoError(t, err)
   163  		v, err := GetValidator(contextWithLogger(t), fakeK8sClient, fakeEventBusClient, fakeEventSourceClient, fakeSensorClient, fromSchemaGVK(eventbusv1alpha1.SchemaGroupVersionKind), nil, byts)
   164  		assert.NoError(t, err)
   165  		assert.NotNil(t, v)
   166  	})
   167  	t.Run("test get EventSource validator", func(t *testing.T) {
   168  		byts, err := json.Marshal(fakeCalendarEventSource())
   169  		assert.NoError(t, err)
   170  		v, err := GetValidator(contextWithLogger(t), fakeK8sClient, fakeEventBusClient, fakeEventSourceClient, fakeSensorClient, fromSchemaGVK(eventsourcev1alpha1.SchemaGroupVersionKind), nil, byts)
   171  		assert.NoError(t, err)
   172  		assert.NotNil(t, v)
   173  	})
   174  	t.Run("test get Sensor validator", func(t *testing.T) {
   175  		byts, err := json.Marshal(fakeSensor())
   176  		assert.NoError(t, err)
   177  		v, err := GetValidator(contextWithLogger(t), fakeK8sClient, fakeEventBusClient, fakeEventSourceClient, fakeSensorClient, fromSchemaGVK(sensorv1alpha1.SchemaGroupVersionKind), nil, byts)
   178  		assert.NoError(t, err)
   179  		assert.NotNil(t, v)
   180  	})
   181  }