github.com/argoproj-labs/argocd-operator@v0.10.0/controllers/argocd/ingress_test.go (about)

     1  package argocd
     2  
     3  import (
     4  	"context"
     5  	"testing"
     6  
     7  	"github.com/stretchr/testify/assert"
     8  	networkingv1 "k8s.io/api/networking/v1"
     9  	"k8s.io/apimachinery/pkg/runtime"
    10  	"k8s.io/apimachinery/pkg/types"
    11  	"sigs.k8s.io/controller-runtime/pkg/client"
    12  	logf "sigs.k8s.io/controller-runtime/pkg/log"
    13  
    14  	argoproj "github.com/argoproj-labs/argocd-operator/api/v1beta1"
    15  	"github.com/argoproj-labs/argocd-operator/common"
    16  )
    17  
    18  func TestReconcileArgoCD_reconcile_ServerIngress_ingressClassName(t *testing.T) {
    19  	logf.SetLogger(ZapLogger(true))
    20  
    21  	nginx := "nginx"
    22  
    23  	tests := []struct {
    24  		name             string
    25  		ingressClassName *string
    26  	}{
    27  		{
    28  			name:             "undefined ingress class name",
    29  			ingressClassName: nil,
    30  		},
    31  		{
    32  			name:             "ingress class name specified",
    33  			ingressClassName: &nginx,
    34  		},
    35  	}
    36  
    37  	for _, test := range tests {
    38  		t.Run(test.name, func(t *testing.T) {
    39  
    40  			a := makeTestArgoCD(func(a *argoproj.ArgoCD) {
    41  				a.Spec.Server.Ingress.Enabled = true
    42  				a.Spec.Server.Ingress.IngressClassName = test.ingressClassName
    43  			})
    44  
    45  			resObjs := []client.Object{a}
    46  			subresObjs := []client.Object{a}
    47  			runtimeObjs := []runtime.Object{}
    48  			sch := makeTestReconcilerScheme(argoproj.AddToScheme)
    49  			cl := makeTestReconcilerClient(sch, resObjs, subresObjs, runtimeObjs)
    50  			r := makeTestReconciler(cl, sch)
    51  
    52  			err := r.reconcileArgoServerIngress(a)
    53  			assert.NoError(t, err)
    54  
    55  			ingress := &networkingv1.Ingress{}
    56  			err = r.Client.Get(context.TODO(), types.NamespacedName{
    57  				Name:      "argocd-server",
    58  				Namespace: testNamespace,
    59  			}, ingress)
    60  			assert.NoError(t, err)
    61  			assert.Equal(t, test.ingressClassName, ingress.Spec.IngressClassName)
    62  		})
    63  	}
    64  }
    65  
    66  func TestReconcileArgoCD_reconcile_ServerGRPCIngress_ingressClassName(t *testing.T) {
    67  	logf.SetLogger(ZapLogger(true))
    68  
    69  	nginx := "nginx"
    70  
    71  	tests := []struct {
    72  		name             string
    73  		ingressClassName *string
    74  	}{
    75  		{
    76  			name:             "undefined ingress class name",
    77  			ingressClassName: nil,
    78  		},
    79  		{
    80  			name:             "ingress class name specified",
    81  			ingressClassName: &nginx,
    82  		},
    83  	}
    84  
    85  	for _, test := range tests {
    86  		t.Run(test.name, func(t *testing.T) {
    87  
    88  			a := makeTestArgoCD(func(a *argoproj.ArgoCD) {
    89  				a.Spec.Server.GRPC.Ingress.Enabled = true
    90  				a.Spec.Server.GRPC.Ingress.IngressClassName = test.ingressClassName
    91  			})
    92  
    93  			resObjs := []client.Object{a}
    94  			subresObjs := []client.Object{a}
    95  			runtimeObjs := []runtime.Object{}
    96  			sch := makeTestReconcilerScheme(argoproj.AddToScheme)
    97  			cl := makeTestReconcilerClient(sch, resObjs, subresObjs, runtimeObjs)
    98  			r := makeTestReconciler(cl, sch)
    99  
   100  			err := r.reconcileArgoServerGRPCIngress(a)
   101  			assert.NoError(t, err)
   102  
   103  			ingress := &networkingv1.Ingress{}
   104  			err = r.Client.Get(context.TODO(), types.NamespacedName{
   105  				Name:      "argocd-grpc",
   106  				Namespace: testNamespace,
   107  			}, ingress)
   108  			assert.NoError(t, err)
   109  			assert.Equal(t, test.ingressClassName, ingress.Spec.IngressClassName)
   110  		})
   111  	}
   112  }
   113  
   114  func TestReconcileArgoCD_reconcile_PrometheusIngress_ingressClassName(t *testing.T) {
   115  	logf.SetLogger(ZapLogger(true))
   116  
   117  	nginx := "nginx"
   118  
   119  	tests := []struct {
   120  		name             string
   121  		ingressClassName *string
   122  	}{
   123  		{
   124  			name:             "undefined ingress class name",
   125  			ingressClassName: nil,
   126  		},
   127  		{
   128  			name:             "ingress class name specified",
   129  			ingressClassName: &nginx,
   130  		},
   131  	}
   132  
   133  	for _, test := range tests {
   134  		t.Run(test.name, func(t *testing.T) {
   135  
   136  			a := makeTestArgoCD(func(a *argoproj.ArgoCD) {
   137  				a.Spec.Prometheus.Enabled = true
   138  				a.Spec.Prometheus.Ingress.Enabled = true
   139  				a.Spec.Prometheus.Ingress.IngressClassName = test.ingressClassName
   140  			})
   141  
   142  			resObjs := []client.Object{a}
   143  			subresObjs := []client.Object{a}
   144  			runtimeObjs := []runtime.Object{}
   145  			sch := makeTestReconcilerScheme(argoproj.AddToScheme)
   146  			cl := makeTestReconcilerClient(sch, resObjs, subresObjs, runtimeObjs)
   147  			r := makeTestReconciler(cl, sch)
   148  
   149  			err := r.reconcilePrometheusIngress(a)
   150  			assert.NoError(t, err)
   151  
   152  			ingress := &networkingv1.Ingress{}
   153  			err = r.Client.Get(context.TODO(), types.NamespacedName{
   154  				Name:      "argocd-prometheus",
   155  				Namespace: testNamespace,
   156  			}, ingress)
   157  			assert.NoError(t, err)
   158  			assert.Equal(t, test.ingressClassName, ingress.Spec.IngressClassName)
   159  		})
   160  	}
   161  }
   162  
   163  func TestReconcileApplicationSetService_Ingress(t *testing.T) {
   164  	logf.SetLogger(ZapLogger(true))
   165  	a := makeTestArgoCD()
   166  	obj := argoproj.ArgoCDApplicationSet{
   167  		WebhookServer: argoproj.WebhookServerSpec{
   168  			Ingress: argoproj.ArgoCDIngressSpec{
   169  				Enabled: true,
   170  			},
   171  		},
   172  	}
   173  	a.Spec.ApplicationSet = &obj
   174  
   175  	resObjs := []client.Object{a}
   176  	subresObjs := []client.Object{a}
   177  	runtimeObjs := []runtime.Object{}
   178  	sch := makeTestReconcilerScheme(argoproj.AddToScheme)
   179  	cl := makeTestReconcilerClient(sch, resObjs, subresObjs, runtimeObjs)
   180  	r := makeTestReconciler(cl, sch)
   181  
   182  	ingress := newIngressWithSuffix(common.ApplicationSetServiceNameSuffix, a)
   183  	assert.NoError(t, r.reconcileApplicationSetControllerIngress(a))
   184  	assert.NoError(t, r.Client.Get(context.TODO(), types.NamespacedName{Namespace: ingress.Namespace, Name: ingress.Name}, ingress))
   185  }