util_test.go

Documentation: k8s.io/kubernetes/pkg/probe

     1  /*
     2  Copyright 2022 The Kubernetes Authors.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8      http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package probe
    18  
    19  import (
    20  	"testing"
    21  
    22  	v1 "k8s.io/api/core/v1"
    23  	"k8s.io/apimachinery/pkg/util/intstr"
    24  )
    25  
    26  func TestFindPortByName(t *testing.T) {
    27  	t.Parallel()
    28  	type args struct {
    29  		container *v1.Container
    30  		portName  string
    31  	}
    32  	tests := []struct {
    33  		name    string
    34  		args    args
    35  		want    int
    36  		wantErr bool
    37  	}{
    38  		{
    39  			name: "get port from exist port name",
    40  			args: args{
    41  				container: &v1.Container{
    42  					Ports: []v1.ContainerPort{
    43  						{
    44  							Name:          "foo",
    45  							ContainerPort: 8080,
    46  						},
    47  						{
    48  							Name:          "bar",
    49  							ContainerPort: 9000,
    50  						},
    51  					},
    52  				},
    53  				portName: "foo",
    54  			},
    55  			want:    8080,
    56  			wantErr: false,
    57  		},
    58  		{
    59  			name: "get port from not exist port name",
    60  			args: args{
    61  				container: &v1.Container{
    62  					Ports: []v1.ContainerPort{
    63  						{
    64  							Name:          "foo",
    65  							ContainerPort: 8080,
    66  						},
    67  						{
    68  							Name:          "bar",
    69  							ContainerPort: 9000,
    70  						},
    71  					},
    72  				},
    73  				portName: "http",
    74  			},
    75  			want:    0,
    76  			wantErr: true,
    77  		},
    78  	}
    79  
    80  	for _, tt := range tests {
    81  		tt := tt
    82  		t.Run(tt.name, func(t *testing.T) {
    83  			t.Parallel()
    84  			got, err := findPortByName(tt.args.container, tt.args.portName)
    85  			if (err != nil) != tt.wantErr {
    86  				t.Errorf("findPortByName() error = %v, wantErr %v", err, tt.wantErr)
    87  				return
    88  			}
    89  			if got != tt.want {
    90  				t.Errorf("findPortByName() = %v, want %v", got, tt.want)
    91  			}
    92  		})
    93  	}
    94  }
    95  
    96  func TestResolveContainerPort(t *testing.T) {
    97  	t.Parallel()
    98  	type args struct {
    99  		param     intstr.IntOrString
   100  		container *v1.Container
   101  	}
   102  	tests := []struct {
   103  		name    string
   104  		args    args
   105  		want    int
   106  		wantErr bool
   107  	}{
   108  		{
   109  			name: "get port by int type",
   110  			args: args{
   111  				param:     intstr.IntOrString{Type: 0, IntVal: 443},
   112  				container: &v1.Container{},
   113  			},
   114  			want:    443,
   115  			wantErr: false,
   116  		},
   117  		{
   118  			name: "invalid port",
   119  			args: args{
   120  				param:     intstr.IntOrString{Type: 0, IntVal: 66666},
   121  				container: &v1.Container{},
   122  			},
   123  			want:    66666,
   124  			wantErr: true,
   125  		},
   126  		{
   127  			name: "get port by port name",
   128  			args: args{
   129  				param: intstr.IntOrString{Type: 1, StrVal: "foo"},
   130  				container: &v1.Container{
   131  					Ports: []v1.ContainerPort{
   132  						{
   133  							Name:          "foo",
   134  							ContainerPort: 8080,
   135  						},
   136  						{
   137  							Name:          "bar",
   138  							ContainerPort: 9000,
   139  						},
   140  					},
   141  				},
   142  			},
   143  			want:    8080,
   144  			wantErr: false,
   145  		},
   146  		{
   147  			name: "no port name",
   148  			args: args{
   149  				param: intstr.IntOrString{Type: 1, StrVal: "foo"},
   150  				container: &v1.Container{
   151  					Ports: []v1.ContainerPort{
   152  						{
   153  							Name:          "bar",
   154  							ContainerPort: 9000,
   155  						},
   156  					},
   157  				},
   158  			},
   159  			want:    0,
   160  			wantErr: true,
   161  		},
   162  		{
   163  			name: "invalid param type",
   164  			args: args{
   165  				param: intstr.IntOrString{Type: 2, StrVal: "foo"},
   166  				container: &v1.Container{
   167  					Ports: []v1.ContainerPort{
   168  						{
   169  							Name:          "foo",
   170  							ContainerPort: 8080,
   171  						},
   172  						{
   173  							Name:          "bar",
   174  							ContainerPort: 9000,
   175  						},
   176  					},
   177  				},
   178  			},
   179  			want:    -1,
   180  			wantErr: true,
   181  		},
   182  	}
   183  	for _, tt := range tests {
   184  		tt := tt
   185  		t.Run(tt.name, func(t *testing.T) {
   186  			t.Parallel()
   187  			got, err := ResolveContainerPort(tt.args.param, tt.args.container)
   188  			if (err != nil) != tt.wantErr {
   189  				t.Errorf("ResolveContainerPort() error = %v, wantErr %v", err, tt.wantErr)
   190  				return
   191  			}
   192  			if got != tt.want {
   193  				t.Errorf("ResolveContainerPort() = %v, want %v", got, tt.want)
   194  			}
   195  		})
   196  	}
   197  }
   198
View as plain text