github.com/argoproj/argo-events@v1.9.1/test/e2e/fixtures/given.go (about)

     1  package fixtures
     2  
     3  import (
     4  	"os"
     5  	"strings"
     6  	"testing"
     7  
     8  	"github.com/stretchr/testify/assert"
     9  	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    10  	"k8s.io/client-go/kubernetes"
    11  	"k8s.io/client-go/rest"
    12  	"sigs.k8s.io/yaml"
    13  
    14  	eventbusv1alpha1 "github.com/argoproj/argo-events/pkg/apis/eventbus/v1alpha1"
    15  	eventsourcev1alpha1 "github.com/argoproj/argo-events/pkg/apis/eventsource/v1alpha1"
    16  	sensorv1alpha1 "github.com/argoproj/argo-events/pkg/apis/sensor/v1alpha1"
    17  	eventbuspkg "github.com/argoproj/argo-events/pkg/client/eventbus/clientset/versioned/typed/eventbus/v1alpha1"
    18  	eventsourcepkg "github.com/argoproj/argo-events/pkg/client/eventsource/clientset/versioned/typed/eventsource/v1alpha1"
    19  	sensorpkg "github.com/argoproj/argo-events/pkg/client/sensor/clientset/versioned/typed/sensor/v1alpha1"
    20  )
    21  
    22  type Given struct {
    23  	t                 *testing.T
    24  	eventBusClient    eventbuspkg.EventBusInterface
    25  	eventSourceClient eventsourcepkg.EventSourceInterface
    26  	sensorClient      sensorpkg.SensorInterface
    27  	eventBus          *eventbusv1alpha1.EventBus
    28  	eventSource       *eventsourcev1alpha1.EventSource
    29  	sensor            *sensorv1alpha1.Sensor
    30  	restConfig        *rest.Config
    31  	kubeClient        kubernetes.Interface
    32  }
    33  
    34  // creates an EventBus based on the parameter, this may be:
    35  //
    36  // 1. A file name if it starts with "@"
    37  // 2. Raw YAML.
    38  func (g *Given) EventBus(text string) *Given {
    39  	g.t.Helper()
    40  	g.eventBus = &eventbusv1alpha1.EventBus{}
    41  	g.readResource(text, g.eventBus)
    42  	l := g.eventBus.GetLabels()
    43  	if l == nil {
    44  		l = map[string]string{}
    45  	}
    46  	l[Label] = LabelValue
    47  	g.eventBus.SetLabels(l)
    48  	g.eventBus.SetName(EventBusName)
    49  	return g
    50  }
    51  
    52  // creates an EventSource based on the parameter, this may be:
    53  //
    54  // 1. A file name if it starts with "@"
    55  // 2. Raw YAML.
    56  func (g *Given) EventSource(text string) *Given {
    57  	g.t.Helper()
    58  	g.eventSource = &eventsourcev1alpha1.EventSource{}
    59  	g.readResource(text, g.eventSource)
    60  	l := g.eventSource.GetLabels()
    61  	if l == nil {
    62  		l = map[string]string{}
    63  	}
    64  	l[Label] = LabelValue
    65  	g.eventSource.SetLabels(l)
    66  	g.eventSource.Spec.EventBusName = EventBusName
    67  	return g
    68  }
    69  
    70  // creates a Sensor based on the parameter, this may be:
    71  //
    72  // 1. A file name if it starts with "@"
    73  // 2. Raw YAML.
    74  func (g *Given) Sensor(text string) *Given {
    75  	g.t.Helper()
    76  	g.sensor = &sensorv1alpha1.Sensor{}
    77  	g.readResource(text, g.sensor)
    78  	l := g.sensor.GetLabels()
    79  	if l == nil {
    80  		l = map[string]string{}
    81  	}
    82  	l[Label] = LabelValue
    83  	g.sensor.SetLabels(l)
    84  	g.sensor.Spec.EventBusName = EventBusName
    85  	return g
    86  }
    87  
    88  func (g *Given) readResource(text string, v metav1.Object) {
    89  	g.t.Helper()
    90  	var file string
    91  	if strings.HasPrefix(text, "@") {
    92  		file = strings.TrimPrefix(text, "@")
    93  	} else {
    94  		f, err := os.CreateTemp("", "argo-events-e2e")
    95  		if err != nil {
    96  			g.t.Fatal(err)
    97  		}
    98  		_, err = f.Write([]byte(text))
    99  		if err != nil {
   100  			g.t.Fatal(err)
   101  		}
   102  		err = f.Close()
   103  		if err != nil {
   104  			g.t.Fatal(err)
   105  		}
   106  		file = f.Name()
   107  	}
   108  
   109  	f, err := os.ReadFile(file)
   110  	if err != nil {
   111  		g.t.Fatal(err)
   112  	}
   113  	err = yaml.Unmarshal(f, v)
   114  	if err != nil {
   115  		g.t.Fatal(err)
   116  	}
   117  }
   118  
   119  func (g *Given) When() *When {
   120  	return &When{
   121  		t:                 g.t,
   122  		eventBusClient:    g.eventBusClient,
   123  		eventSourceClient: g.eventSourceClient,
   124  		sensorClient:      g.sensorClient,
   125  		eventBus:          g.eventBus,
   126  		eventSource:       g.eventSource,
   127  		sensor:            g.sensor,
   128  		restConfig:        g.restConfig,
   129  		kubeClient:        g.kubeClient,
   130  	}
   131  }
   132  
   133  var OutputRegexp = func(rx string) func(t *testing.T, output string, err error) {
   134  	return func(t *testing.T, output string, err error) {
   135  		t.Helper()
   136  		if assert.NoError(t, err, output) {
   137  			assert.Regexp(t, rx, output)
   138  		}
   139  	}
   140  }