github.com/telepresenceio/telepresence/v2@v2.20.0-pro.6.0.20240517030216-236ea954e789/pkg/client/cli/daemon/request_test.go (about)

     1  package daemon
     2  
     3  import (
     4  	"net/netip"
     5  	"reflect"
     6  	"testing"
     7  
     8  	"github.com/telepresenceio/telepresence/rpc/v2/daemon"
     9  )
    10  
    11  func Test_parseSubnetViaWorkload(t *testing.T) {
    12  	tests := []struct {
    13  		name    string
    14  		dps     string
    15  		want    prefixViaWL
    16  		wantErr bool
    17  	}{
    18  		{
    19  			"empty",
    20  			"",
    21  			prefixViaWL{},
    22  			true,
    23  		},
    24  		{
    25  			"workload with dot",
    26  			"127.1.2.3/32=workload.namespace",
    27  			prefixViaWL{},
    28  			true,
    29  		},
    30  		{
    31  			"invalid subnet",
    32  			"bad=workload",
    33  			prefixViaWL{},
    34  			true,
    35  		},
    36  		{
    37  			"ok",
    38  			"127.1.2.3/32=workload",
    39  			prefixViaWL{
    40  				subnet:   netip.MustParsePrefix("127.1.2.3/32"),
    41  				workload: "workload",
    42  			},
    43  			false,
    44  		},
    45  		{
    46  			"all",
    47  			"all=workload",
    48  			prefixViaWL{
    49  				symbolic: "all",
    50  				workload: "workload",
    51  			},
    52  			false,
    53  		},
    54  		{
    55  			"also",
    56  			"also=workload",
    57  			prefixViaWL{
    58  				symbolic: "also",
    59  				workload: "workload",
    60  			},
    61  			false,
    62  		},
    63  		{
    64  			"pods",
    65  			"pods=workload",
    66  			prefixViaWL{
    67  				symbolic: "pods",
    68  				workload: "workload",
    69  			},
    70  			false,
    71  		},
    72  		{
    73  			"service",
    74  			"service=workload",
    75  			prefixViaWL{
    76  				symbolic: "service",
    77  				workload: "workload",
    78  			},
    79  			false,
    80  		},
    81  		{
    82  			"other",
    83  			"other=workload",
    84  			prefixViaWL{},
    85  			true,
    86  		},
    87  	}
    88  	for _, tt := range tests {
    89  		t.Run(tt.name, func(t *testing.T) {
    90  			got, err := parseSubnetViaWorkload(tt.dps)
    91  			if (err != nil) != tt.wantErr {
    92  				t.Errorf("parseDomainProxy(%q) error = %v, wantErr %v", tt.dps, err, tt.wantErr)
    93  				return
    94  			}
    95  			if !reflect.DeepEqual(got, tt.want) {
    96  				t.Errorf("parseDomainProxy(%q) got = %v, want %v", tt.dps, got, tt.want)
    97  			}
    98  		})
    99  	}
   100  }
   101  
   102  func Test_parseProxyVias(t *testing.T) {
   103  	tests := []struct {
   104  		name     string
   105  		proxyVia []string
   106  		want     []*daemon.SubnetViaWorkload
   107  		wantErr  bool
   108  	}{
   109  		{
   110  			name:     "single",
   111  			proxyVia: []string{"127.1.2.0/24=workload"},
   112  			want: []*daemon.SubnetViaWorkload{{
   113  				Subnet:   "127.1.2.0/24",
   114  				Workload: "workload",
   115  			}},
   116  			wantErr: false,
   117  		},
   118  		{
   119  			name:     "multi",
   120  			proxyVia: []string{"127.1.2.0/24=workload1", "127.1.3.0/24=workload2"},
   121  			want: []*daemon.SubnetViaWorkload{
   122  				{
   123  					Subnet:   "127.1.2.0/24",
   124  					Workload: "workload1",
   125  				},
   126  				{
   127  					Subnet:   "127.1.3.0/24",
   128  					Workload: "workload2",
   129  				},
   130  			},
   131  			wantErr: false,
   132  		},
   133  		{
   134  			name:     "multi-overlap",
   135  			proxyVia: []string{"127.1.2.0/16=workload1", "127.1.3.0/16=workload2"},
   136  			want:     nil,
   137  			wantErr:  true,
   138  		},
   139  		{
   140  			name:     "symbolic-overlap",
   141  			proxyVia: []string{"also=workload1", "also=workload2"},
   142  			want:     nil,
   143  			wantErr:  true,
   144  		},
   145  		{
   146  			name:     "symbolic-overlap-all",
   147  			proxyVia: []string{"also=workload1", "all=workload2"},
   148  			want:     nil,
   149  			wantErr:  true,
   150  		},
   151  		{
   152  			name:     "multi-mixed",
   153  			proxyVia: []string{"127.1.2.0/16=workload1", "also=workload2"},
   154  			want: []*daemon.SubnetViaWorkload{
   155  				{
   156  					Subnet:   "127.1.2.0/16",
   157  					Workload: "workload1",
   158  				},
   159  				{
   160  					Subnet:   "also",
   161  					Workload: "workload2",
   162  				},
   163  			},
   164  			wantErr: false,
   165  		},
   166  		{
   167  			name:     "multi-mixed-all",
   168  			proxyVia: []string{"127.1.2.0/16=workload1", "all=workload2"},
   169  			want: []*daemon.SubnetViaWorkload{
   170  				{
   171  					Subnet:   "127.1.2.0/16",
   172  					Workload: "workload1",
   173  				},
   174  				{
   175  					Subnet:   "also",
   176  					Workload: "workload2",
   177  				},
   178  				{
   179  					Subnet:   "pods",
   180  					Workload: "workload2",
   181  				},
   182  				{
   183  					Subnet:   "service",
   184  					Workload: "workload2",
   185  				},
   186  			},
   187  			wantErr: false,
   188  		},
   189  	}
   190  	for _, tt := range tests {
   191  		t.Run(tt.name, func(t *testing.T) {
   192  			got, err := parseProxyVias(tt.proxyVia)
   193  			if (err != nil) != tt.wantErr {
   194  				t.Errorf("parseProxyVias() error = %v, wantErr %v", err, tt.wantErr)
   195  				return
   196  			}
   197  			if !reflect.DeepEqual(got, tt.want) {
   198  				t.Errorf("parseProxyVias() got = %v, want %v", got, tt.want)
   199  			}
   200  		})
   201  	}
   202  }