istio

1
// Copyright Istio Authors. All Rights Reserved.
2
//
3
// Licensed under the Apache License, Version 2.0 (the "License");
4
// you may not use this file except in compliance with the License.
5
// You may obtain a copy of the License at
6
//
7
//     http://www.apache.org/licenses/LICENSE-2.0
8
//
9
// Unless required by applicable law or agreed to in writing, software
10
// distributed under the License is distributed on an "AS IS" BASIS,
11
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12
// See the License for the specific language governing permissions and
13
// limitations under the License.
14

15
package controller
16

17
import (
18
	"testing"
19

20
	core "github.com/envoyproxy/go-control-plane/envoy/config/core/v3"
21
	v1 "k8s.io/api/core/v1"
22

23
	"istio.io/api/label"
24
	"istio.io/istio/pilot/pkg/model"
25
	cluster2 "istio.io/istio/pkg/cluster"
26
	"istio.io/istio/pkg/config/labels"
27
	"istio.io/istio/pkg/network"
28
	"istio.io/istio/pkg/test/util/assert"
29
)
30

31
func TestNewEndpointBuilderTopologyLabels(t *testing.T) {
32
	cases := []struct {
33
		name      string
34
		ctl       testController
35
		podLabels labels.Instance
36
		expected  labels.Instance
37
	}{
38
		{
39
			name:      "empty",
40
			ctl:       testController{},
41
			podLabels: nil,
42
			expected:  labels.Instance{},
43
		},
44
		{
45
			name: "region only",
46
			ctl: testController{
47
				locality: "myregion",
48
			},
49
			podLabels: labels.Instance{
50
				"k1":                       "v1",
51
				label.TopologyNetwork.Name: "mynetwork",
52
			},
53
			expected: labels.Instance{
54
				"k1":                       "v1",
55
				NodeRegionLabelGA:          "myregion",
56
				label.TopologyNetwork.Name: "mynetwork",
57
			},
58
		},
59
		{
60
			name: "region and zone",
61
			ctl: testController{
62
				locality: "myregion/myzone",
63
			},
64
			podLabels: labels.Instance{
65
				"k1":                       "v1",
66
				label.TopologyNetwork.Name: "mynetwork",
67
			},
68
			expected: labels.Instance{
69
				"k1":                       "v1",
70
				NodeRegionLabelGA:          "myregion",
71
				NodeZoneLabelGA:            "myzone",
72
				label.TopologyNetwork.Name: "mynetwork",
73
			},
74
		},
75
		{
76
			name: "network only ",
77
			ctl: testController{
78
				network: "mynetwork",
79
			},
80
			podLabels: labels.Instance{
81
				"k1": "v1",
82
			},
83
			expected: labels.Instance{
84
				"k1":                       "v1",
85
				label.TopologyNetwork.Name: "mynetwork",
86
			},
87
		},
88
		{
89
			name: "network priority",
90
			ctl: testController{
91
				network: "ns-network",
92
			},
93
			podLabels: labels.Instance{
94
				label.TopologyNetwork.Name: "pod-network",
95
			},
96
			expected: labels.Instance{
97
				label.TopologyNetwork.Name: "pod-network",
98
			},
99
		},
100
		{
101
			name: "all values",
102
			ctl: testController{
103
				locality: "myregion/myzone/mysubzone",
104
				cluster:  "mycluster",
105
				network:  "mynetwork",
106
			},
107
			podLabels: labels.Instance{
108
				"k1":                       "v1",
109
				label.TopologyNetwork.Name: "mynetwork",
110
			},
111
			expected: labels.Instance{
112
				"k1":                       "v1",
113
				NodeRegionLabelGA:          "myregion",
114
				NodeZoneLabelGA:            "myzone",
115
				label.TopologySubzone.Name: "mysubzone",
116
				label.TopologyCluster.Name: "mycluster",
117
				label.TopologyNetwork.Name: "mynetwork",
118
			},
119
		},
120
	}
121

122
	for _, c := range cases {
123
		t.Run(c.name, func(t *testing.T) {
124
			pod := v1.Pod{}
125
			pod.Name = "testpod"
126
			pod.Namespace = "testns"
127
			pod.Spec.ServiceAccountName = "testsan"
128
			pod.Labels = c.podLabels
129

130
			eb := NewEndpointBuilder(c.ctl, &pod)
131

132
			assert.Equal(t, eb.labels, c.expected)
133
		})
134
	}
135
}
136

137
func TestNewEndpointBuilderFromMetadataTopologyLabels(t *testing.T) {
138
	cases := []struct {
139
		name     string
140
		ctl      testController
141
		proxy    *model.Proxy
142
		expected labels.Instance
143
	}{
144
		{
145
			name: "empty",
146
			ctl:  testController{},
147
			proxy: &model.Proxy{
148
				Metadata: &model.NodeMetadata{},
149
			},
150
			expected: labels.Instance{},
151
		},
152
		{
153
			name: "region only",
154
			ctl:  testController{},
155
			proxy: &model.Proxy{
156
				Labels: labels.Instance{
157
					"k1":                       "v1",
158
					label.TopologyNetwork.Name: "mynetwork",
159
				},
160
				Metadata: &model.NodeMetadata{
161
					Labels: labels.Instance{
162
						"k1":                       "v1",
163
						label.TopologyNetwork.Name: "mynetwork",
164
					},
165
				},
166
				Locality: &core.Locality{
167
					Region: "myregion",
168
				},
169
			},
170
			expected: labels.Instance{
171
				"k1":                       "v1",
172
				NodeRegionLabelGA:          "myregion",
173
				label.TopologyNetwork.Name: "mynetwork",
174
			},
175
		},
176
		{
177
			name: "region and zone",
178
			ctl:  testController{},
179
			proxy: &model.Proxy{
180
				Labels: labels.Instance{
181
					"k1":                       "v1",
182
					label.TopologyNetwork.Name: "mynetwork",
183
				},
184
				Metadata: &model.NodeMetadata{
185
					Labels: labels.Instance{
186
						"k1":                       "v1",
187
						label.TopologyNetwork.Name: "mynetwork",
188
					},
189
				},
190
				Locality: &core.Locality{
191
					Region: "myregion",
192
					Zone:   "myzone",
193
				},
194
			},
195
			expected: labels.Instance{
196
				"k1":                       "v1",
197
				NodeRegionLabelGA:          "myregion",
198
				NodeZoneLabelGA:            "myzone",
199
				label.TopologyNetwork.Name: "mynetwork",
200
			},
201
		},
202
		{
203
			name: "all values set",
204
			ctl: testController{
205
				cluster: "mycluster",
206
			},
207
			proxy: &model.Proxy{
208
				Labels: labels.Instance{
209
					"k1":                       "v1",
210
					label.TopologyNetwork.Name: "mynetwork",
211
				},
212
				Metadata: &model.NodeMetadata{
213
					Labels: labels.Instance{
214
						"k1":                       "v1",
215
						label.TopologyNetwork.Name: "mynetwork",
216
					},
217
				},
218
				Locality: &core.Locality{
219
					Region:  "myregion",
220
					Zone:    "myzone",
221
					SubZone: "mysubzone",
222
				},
223
			},
224
			expected: labels.Instance{
225
				"k1":                       "v1",
226
				NodeRegionLabelGA:          "myregion",
227
				NodeZoneLabelGA:            "myzone",
228
				label.TopologySubzone.Name: "mysubzone",
229
				label.TopologyCluster.Name: "mycluster",
230
				label.TopologyNetwork.Name: "mynetwork",
231
			},
232
		},
233
	}
234

235
	for _, c := range cases {
236
		t.Run(c.name, func(t *testing.T) {
237
			eb := NewEndpointBuilderFromMetadata(c.ctl, c.proxy)
238

239
			assert.Equal(t, eb.labels, c.expected)
240
		})
241
	}
242
}
243

244
var _ controllerInterface = testController{}
245

246
type testController struct {
247
	locality string
248
	cluster  cluster2.ID
249
	network  network.ID
250
}
251

252
func (c testController) getPodLocality(*v1.Pod) string {
253
	return c.locality
254
}
255

256
func (c testController) Network(ip string, instance labels.Instance) network.ID {
257
	if n := instance[label.TopologyNetwork.Name]; n != "" {
258
		return network.ID(n)
259
	}
260
	return c.network
261
}
262

263
func (c testController) Cluster() cluster2.ID {
264
	return c.cluster
265
}
266