github.com/argoproj/argo-cd/v3@v3.2.1/test/testdata.go (about)

     1  package test
     2  
     3  import (
     4  	"context"
     5  
     6  	"github.com/alicebob/miniredis/v2"
     7  	"github.com/argoproj/gitops-engine/pkg/utils/testing"
     8  	"github.com/redis/go-redis/v9"
     9  	corev1 "k8s.io/api/core/v1"
    10  	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    11  	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
    12  	"k8s.io/apimachinery/pkg/labels"
    13  	"k8s.io/apimachinery/pkg/runtime"
    14  
    15  	"github.com/argoproj/argo-cd/v3/common"
    16  	"github.com/argoproj/argo-cd/v3/pkg/apis/application/v1alpha1"
    17  	apps "github.com/argoproj/argo-cd/v3/pkg/client/clientset/versioned/fake"
    18  	appclient "github.com/argoproj/argo-cd/v3/pkg/client/clientset/versioned/typed/application/v1alpha1"
    19  	appinformer "github.com/argoproj/argo-cd/v3/pkg/client/informers/externalversions"
    20  	applister "github.com/argoproj/argo-cd/v3/pkg/client/listers/application/v1alpha1"
    21  )
    22  
    23  const (
    24  	FakeArgoCDNamespace = "fake-argocd-ns"
    25  	FakeDestNamespace   = "fake-dest-ns"
    26  	FakeClusterURL      = "https://fake-cluster:443"
    27  )
    28  
    29  func NewControllerRevision() *unstructured.Unstructured {
    30  	return testing.Unstructured(`
    31  kind: ControllerRevision
    32  apiVersion: metacontroller.k8s.io/v1alpha1
    33  metadata:
    34    labels:
    35      app: nginx
    36      controller.kubernetes.io/hash: c7cd8d57f
    37    name: web-c7cd8d57f
    38    namespace: statefulset
    39  revision: 2
    40  `)
    41  }
    42  
    43  var DeploymentManifest = `
    44  {
    45    "apiVersion": "apps/v1",
    46    "kind": "Deployment",
    47    "metadata": {
    48      "name": "nginx-deployment",
    49      "labels": {
    50        "app": "nginx"
    51      }
    52    },
    53    "spec": {
    54      "replicas": 3,
    55      "selector": {
    56        "matchLabels": {
    57          "app": "nginx"
    58        }
    59      },
    60      "template": {
    61        "metadata": {
    62          "labels": {
    63            "app": "nginx"
    64          }
    65        },
    66        "spec": {
    67          "containers": [
    68            {
    69              "name": "nginx",
    70              "image": "nginx:1.15.4",
    71              "ports": [
    72                {
    73                  "containerPort": 80
    74                }
    75              ]
    76            }
    77          ]
    78        }
    79      }
    80    }
    81  }
    82  `
    83  
    84  func NewDeployment() *unstructured.Unstructured {
    85  	return testing.Unstructured(DeploymentManifest)
    86  }
    87  
    88  var ConfigMapManifest = `
    89  {	
    90    "apiVersion": "v1",
    91    "kind": "ConfigMap",
    92    "metadata": {
    93      "name": "my-configmap",
    94    },
    95    "data": {
    96      "config.yaml": "auth: token\nconfig:field"
    97    }
    98  }`
    99  
   100  func NewConfigMap() *unstructured.Unstructured {
   101  	return testing.Unstructured(ConfigMapManifest)
   102  }
   103  
   104  func NewFakeConfigMap() *corev1.ConfigMap {
   105  	cm := corev1.ConfigMap{
   106  		TypeMeta: metav1.TypeMeta{
   107  			Kind:       "ConfigMap",
   108  			APIVersion: "v1",
   109  		},
   110  		ObjectMeta: metav1.ObjectMeta{
   111  			Name:      common.ArgoCDConfigMapName,
   112  			Namespace: FakeArgoCDNamespace,
   113  			Labels: map[string]string{
   114  				"app.kubernetes.io/part-of": "argocd",
   115  			},
   116  		},
   117  		Data: make(map[string]string),
   118  	}
   119  	return &cm
   120  }
   121  
   122  func NewFakeSecret() *corev1.Secret {
   123  	secret := corev1.Secret{
   124  		TypeMeta: metav1.TypeMeta{
   125  			Kind:       "Secret",
   126  			APIVersion: "v1",
   127  		},
   128  		ObjectMeta: metav1.ObjectMeta{
   129  			Name:      common.ArgoCDSecretName,
   130  			Namespace: FakeArgoCDNamespace,
   131  		},
   132  		Data: map[string][]byte{
   133  			"admin.password":   []byte("test"),
   134  			"server.secretkey": []byte("test"),
   135  		},
   136  	}
   137  	return &secret
   138  }
   139  
   140  type interfaceLister struct {
   141  	appProjects appclient.AppProjectInterface
   142  }
   143  
   144  func (l interfaceLister) List(selector labels.Selector) ([]*v1alpha1.AppProject, error) {
   145  	res, err := l.appProjects.List(context.Background(), metav1.ListOptions{LabelSelector: selector.String()})
   146  	if err != nil {
   147  		return nil, err
   148  	}
   149  	items := make([]*v1alpha1.AppProject, len(res.Items))
   150  	for i := range res.Items {
   151  		items[i] = &res.Items[i]
   152  	}
   153  	return items, nil
   154  }
   155  
   156  func (l interfaceLister) Get(name string) (*v1alpha1.AppProject, error) {
   157  	return l.appProjects.Get(context.Background(), name, metav1.GetOptions{})
   158  }
   159  
   160  func NewFakeProjListerFromInterface(appProjects appclient.AppProjectInterface) applister.AppProjectNamespaceLister {
   161  	return &interfaceLister{appProjects: appProjects}
   162  }
   163  
   164  func NewFakeProjLister(objects ...runtime.Object) applister.AppProjectNamespaceLister {
   165  	fakeAppClientset := apps.NewSimpleClientset(objects...)
   166  	factory := appinformer.NewSharedInformerFactoryWithOptions(fakeAppClientset, 0, appinformer.WithNamespace(""), appinformer.WithTweakListOptions(func(_ *metav1.ListOptions) {}))
   167  	projInformer := factory.Argoproj().V1alpha1().AppProjects().Informer()
   168  	cancel := StartInformer(projInformer)
   169  	defer cancel()
   170  	return factory.Argoproj().V1alpha1().AppProjects().Lister().AppProjects(FakeArgoCDNamespace)
   171  }
   172  
   173  func NewInMemoryRedis() (*redis.Client, func()) {
   174  	mr, err := miniredis.Run()
   175  	if err != nil {
   176  		panic(err)
   177  	}
   178  	return redis.NewClient(&redis.Options{Addr: mr.Addr()}), mr.Close
   179  }