github.com/aporeto-inc/trireme-lib@v10.358.0+incompatible/monitor/internal/kubernetes/client_test.go (about)

     1  // +build !windows
     2  
     3  package kubernetesmonitor
     4  
     5  import (
     6  	"reflect"
     7  	"testing"
     8  
     9  	"go.aporeto.io/trireme-lib/monitor/config"
    10  	"go.aporeto.io/trireme-lib/monitor/extractors"
    11  	dockermonitor "go.aporeto.io/trireme-lib/monitor/internal/docker"
    12  	api "k8s.io/api/core/v1"
    13  	kubefields "k8s.io/apimachinery/pkg/fields"
    14  	"k8s.io/client-go/kubernetes"
    15  	kubefake "k8s.io/client-go/kubernetes/fake"
    16  	kubecache "k8s.io/client-go/tools/cache"
    17  )
    18  
    19  func TestNewKubeClient(t *testing.T) {
    20  	type args struct {
    21  		kubeconfig string
    22  	}
    23  	tests := []struct {
    24  		name    string
    25  		args    args
    26  		want    *kubernetes.Clientset
    27  		wantErr bool
    28  	}{
    29  		{
    30  			name: "test1",
    31  			args: args{
    32  				kubeconfig: "/tmp/abcd",
    33  			},
    34  			want:    nil,
    35  			wantErr: true,
    36  		},
    37  	}
    38  	for _, tt := range tests {
    39  		t.Run(tt.name, func(t *testing.T) {
    40  			got, err := NewKubeClient(tt.args.kubeconfig)
    41  			if (err != nil) != tt.wantErr {
    42  				t.Errorf("NewKubeClient() error = %v, wantErr %v", err, tt.wantErr)
    43  				return
    44  			}
    45  			if !reflect.DeepEqual(got, tt.want) {
    46  				t.Errorf("NewKubeClient() = %v, want %v", got, tt.want)
    47  			}
    48  		})
    49  	}
    50  }
    51  
    52  func TestKubernetesMonitor_Pod(t *testing.T) {
    53  
    54  	pod1 := &api.Pod{}
    55  	pod1.SetName("pod1")
    56  	pod1.SetNamespace("beer")
    57  
    58  	type fields struct {
    59  		dockerMonitor       *dockermonitor.DockerMonitor
    60  		kubeClient          kubernetes.Interface
    61  		localNode           string
    62  		handlers            *config.ProcessorConfig
    63  		cache               *cache
    64  		kubernetesExtractor extractors.KubernetesMetadataExtractorType
    65  		podStore            kubecache.Store
    66  		podController       kubecache.Controller
    67  		podControllerStop   chan struct{}
    68  		enableHostPods      bool
    69  	}
    70  	type args struct {
    71  		podName   string
    72  		namespace string
    73  	}
    74  	tests := []struct {
    75  		name    string
    76  		fields  fields
    77  		args    args
    78  		want    *api.Pod
    79  		wantErr bool
    80  	}{
    81  		{
    82  			name: "Query existing pod",
    83  			fields: fields{
    84  				kubeClient: kubefake.NewSimpleClientset(pod1),
    85  			},
    86  			args: args{
    87  				podName:   "pod1",
    88  				namespace: "beer",
    89  			},
    90  			want:    pod1,
    91  			wantErr: false,
    92  		},
    93  		{
    94  			name: "Query non existing pod",
    95  			fields: fields{
    96  				kubeClient: kubefake.NewSimpleClientset(pod1),
    97  			},
    98  			args: args{
    99  				podName:   "pod2",
   100  				namespace: "beer",
   101  			},
   102  			want:    nil,
   103  			wantErr: true,
   104  		},
   105  	}
   106  	for _, tt := range tests {
   107  		t.Run(tt.name, func(t *testing.T) {
   108  			m := &KubernetesMonitor{
   109  				dockerMonitor:       tt.fields.dockerMonitor,
   110  				kubeClient:          tt.fields.kubeClient,
   111  				localNode:           tt.fields.localNode,
   112  				handlers:            tt.fields.handlers,
   113  				cache:               tt.fields.cache,
   114  				kubernetesExtractor: tt.fields.kubernetesExtractor,
   115  				podStore:            tt.fields.podStore,
   116  				podController:       tt.fields.podController,
   117  				podControllerStop:   tt.fields.podControllerStop,
   118  				enableHostPods:      tt.fields.enableHostPods,
   119  			}
   120  			got, err := m.Pod(tt.args.podName, tt.args.namespace)
   121  			if (err != nil) != tt.wantErr {
   122  				t.Errorf("KubernetesMonitor.Pod() error = %v, wantErr %v", err, tt.wantErr)
   123  				return
   124  			}
   125  			if !reflect.DeepEqual(got, tt.want) {
   126  				t.Errorf("KubernetesMonitor.Pod() = %v, want %v", got, tt.want)
   127  			}
   128  		})
   129  	}
   130  }
   131  
   132  func TestKubernetesMonitor_localNodeSelector(t *testing.T) {
   133  	type fields struct {
   134  		dockerMonitor       *dockermonitor.DockerMonitor
   135  		kubeClient          kubernetes.Interface
   136  		localNode           string
   137  		handlers            *config.ProcessorConfig
   138  		cache               *cache
   139  		kubernetesExtractor extractors.KubernetesMetadataExtractorType
   140  		podStore            kubecache.Store
   141  		podController       kubecache.Controller
   142  		podControllerStop   chan struct{}
   143  		enableHostPods      bool
   144  	}
   145  	tests := []struct {
   146  		name   string
   147  		fields fields
   148  		want   kubefields.Selector
   149  	}{
   150  		{
   151  			name: "Normal string",
   152  			fields: fields{
   153  				localNode: "abc",
   154  			},
   155  			want: kubefields.Set(map[string]string{
   156  				"spec.nodeName": "abc",
   157  			}).AsSelector(),
   158  		},
   159  		{
   160  			name: "Empty string",
   161  			fields: fields{
   162  				localNode: "",
   163  			},
   164  			want: kubefields.Set(map[string]string{
   165  				"spec.nodeName": "",
   166  			}).AsSelector(),
   167  		},
   168  	}
   169  	for _, tt := range tests {
   170  		t.Run(tt.name, func(t *testing.T) {
   171  			m := &KubernetesMonitor{
   172  				dockerMonitor:       tt.fields.dockerMonitor,
   173  				kubeClient:          tt.fields.kubeClient,
   174  				localNode:           tt.fields.localNode,
   175  				handlers:            tt.fields.handlers,
   176  				cache:               tt.fields.cache,
   177  				kubernetesExtractor: tt.fields.kubernetesExtractor,
   178  				podStore:            tt.fields.podStore,
   179  				podController:       tt.fields.podController,
   180  				podControllerStop:   tt.fields.podControllerStop,
   181  				enableHostPods:      tt.fields.enableHostPods,
   182  			}
   183  			if got := m.localNodeSelector(); !reflect.DeepEqual(got, tt.want) {
   184  				t.Errorf("KubernetesMonitor.localNodeSelector() = %v, want %v", got, tt.want)
   185  			}
   186  		})
   187  	}
   188  }