github.com/looshlee/beatles@v0.0.0-20220727174639-742810ab631c/pkg/node/node_test.go (about) 1 // Copyright 2016-2019 Authors of Cilium 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 // +build !privileged_tests 16 17 package node 18 19 import ( 20 "net" 21 "testing" 22 23 "github.com/cilium/cilium/pkg/checker" 24 "github.com/cilium/cilium/pkg/cidr" 25 ciliumv2 "github.com/cilium/cilium/pkg/k8s/apis/cilium.io/v2" 26 "github.com/cilium/cilium/pkg/node/addressing" 27 "github.com/cilium/cilium/pkg/source" 28 29 . "gopkg.in/check.v1" 30 metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" 31 ) 32 33 // Hook up gocheck into the "go test" runner. 34 func Test(t *testing.T) { 35 TestingT(t) 36 } 37 38 type NodeSuite struct{} 39 40 var _ = Suite(&NodeSuite{}) 41 42 func (s *NodeSuite) TestGetNodeIP(c *C) { 43 n := Node{ 44 Name: "node-1", 45 IPAddresses: []Address{ 46 {IP: net.ParseIP("192.0.2.3"), Type: addressing.NodeExternalIP}, 47 }, 48 } 49 ip := n.GetNodeIP(false) 50 // Return the only IP present 51 c.Assert(ip.Equal(net.ParseIP("192.0.2.3")), Equals, true) 52 53 n.IPAddresses = append(n.IPAddresses, Address{IP: net.ParseIP("192.0.2.3"), Type: addressing.NodeExternalIP}) 54 ip = n.GetNodeIP(false) 55 // The next priority should be NodeExternalIP 56 c.Assert(ip.Equal(net.ParseIP("192.0.2.3")), Equals, true) 57 58 n.IPAddresses = append(n.IPAddresses, Address{IP: net.ParseIP("198.51.100.2"), Type: addressing.NodeInternalIP}) 59 ip = n.GetNodeIP(false) 60 // The next priority should be NodeInternalIP 61 c.Assert(ip.Equal(net.ParseIP("198.51.100.2")), Equals, true) 62 63 n.IPAddresses = append(n.IPAddresses, Address{IP: net.ParseIP("2001:DB8::1"), Type: addressing.NodeExternalIP}) 64 ip = n.GetNodeIP(true) 65 // The next priority should be NodeExternalIP and IPv6 66 c.Assert(ip.Equal(net.ParseIP("2001:DB8::1")), Equals, true) 67 68 n.IPAddresses = append(n.IPAddresses, Address{IP: net.ParseIP("2001:DB8::2"), Type: addressing.NodeInternalIP}) 69 ip = n.GetNodeIP(true) 70 // The next priority should be NodeInternalIP and IPv6 71 c.Assert(ip.Equal(net.ParseIP("2001:DB8::2")), Equals, true) 72 73 n.IPAddresses = append(n.IPAddresses, Address{IP: net.ParseIP("198.51.100.2"), Type: addressing.NodeInternalIP}) 74 ip = n.GetNodeIP(false) 75 // Should still return NodeInternalIP and IPv4 76 c.Assert(ip.Equal(net.ParseIP("198.51.100.2")), Equals, true) 77 78 } 79 80 func (s *NodeSuite) TestParseCiliumNode(c *C) { 81 nodeResource := &ciliumv2.CiliumNode{ 82 ObjectMeta: metav1.ObjectMeta{Name: "foo", Namespace: "default"}, 83 Spec: ciliumv2.NodeSpec{ 84 Addresses: []ciliumv2.NodeAddress{ 85 {Type: addressing.NodeInternalIP, IP: "2.2.2.2"}, 86 {Type: addressing.NodeExternalIP, IP: "3.3.3.3"}, 87 {Type: addressing.NodeInternalIP, IP: "c0de::1"}, 88 {Type: addressing.NodeExternalIP, IP: "c0de::2"}, 89 }, 90 Encryption: ciliumv2.EncryptionSpec{ 91 Key: 10, 92 }, 93 IPAM: ciliumv2.IPAMSpec{ 94 PodCIDRs: []string{ 95 "10.10.0.0/16", 96 "c0de::/96", 97 }, 98 }, 99 HealthAddressing: ciliumv2.HealthAddressingSpec{ 100 IPv4: "1.1.1.1", 101 IPv6: "c0de::1", 102 }, 103 }, 104 } 105 106 n := ParseCiliumNode(nodeResource) 107 c.Assert(n, checker.DeepEquals, Node{ 108 Name: "foo", 109 Source: source.CustomResource, 110 IPAddresses: []Address{ 111 {Type: addressing.NodeInternalIP, IP: net.ParseIP("2.2.2.2")}, 112 {Type: addressing.NodeExternalIP, IP: net.ParseIP("3.3.3.3")}, 113 {Type: addressing.NodeInternalIP, IP: net.ParseIP("c0de::1")}, 114 {Type: addressing.NodeExternalIP, IP: net.ParseIP("c0de::2")}, 115 }, 116 EncryptionKey: uint8(10), 117 IPv4AllocCIDR: cidr.MustParseCIDR("10.10.0.0/16"), 118 IPv6AllocCIDR: cidr.MustParseCIDR("c0de::/96"), 119 IPv4HealthIP: net.ParseIP("1.1.1.1"), 120 IPv6HealthIP: net.ParseIP("c0de::1"), 121 }) 122 } 123 124 func (s *NodeSuite) TestPublicAttrEquals(c *C) { 125 type fields struct { 126 Name string 127 Cluster string 128 IPAddresses []Address 129 IPv4AllocCIDR *cidr.CIDR 130 IPv6AllocCIDR *cidr.CIDR 131 IPv4HealthIP net.IP 132 IPv6HealthIP net.IP 133 ClusterID int 134 Source source.Source 135 } 136 type args struct { 137 o *Node 138 } 139 tests := []struct { 140 name string 141 fields fields 142 args args 143 want bool 144 }{ 145 { 146 name: "test nil equalness", 147 fields: fields{}, 148 args: args{o: nil}, 149 want: false, 150 }, 151 { 152 name: "test equalness", 153 fields: fields{ 154 Name: "foo", 155 Cluster: "cluster-1", 156 IPv4HealthIP: net.ParseIP("1.1.1.1"), 157 IPv6HealthIP: net.ParseIP("fd00::1"), 158 ClusterID: 1, 159 Source: source.Kubernetes, 160 IPAddresses: []Address{{IP: net.ParseIP("1.1.1.1"), Type: addressing.NodeHostName}}, 161 IPv4AllocCIDR: cidr.MustParseCIDR("1.1.1.1/24"), 162 IPv6AllocCIDR: cidr.MustParseCIDR("fd00::1/64"), 163 }, 164 args: args{ 165 o: &Node{ 166 Name: "foo", 167 Cluster: "cluster-1", 168 IPv4HealthIP: net.ParseIP("1.1.1.1"), 169 IPv6HealthIP: net.ParseIP("fd00::1"), 170 ClusterID: 1, 171 Source: source.Kubernetes, 172 IPAddresses: []Address{{IP: net.ParseIP("1.1.1.1"), Type: addressing.NodeHostName}}, 173 IPv4AllocCIDR: cidr.MustParseCIDR("1.1.1.1/24"), 174 IPv6AllocCIDR: cidr.MustParseCIDR("fd00::1/64"), 175 }, 176 }, 177 want: true, 178 }, 179 { 180 name: "test different IPAddresses length", 181 fields: fields{ 182 Name: "foo", 183 Cluster: "cluster-1", 184 IPv4HealthIP: net.ParseIP("1.1.1.1"), 185 IPv6HealthIP: net.ParseIP("fd00::1"), 186 ClusterID: 1, 187 Source: source.Kubernetes, 188 IPAddresses: []Address{{IP: net.ParseIP("1.1.1.1"), Type: addressing.NodeHostName}}, 189 IPv4AllocCIDR: cidr.MustParseCIDR("1.1.1.1/24"), 190 IPv6AllocCIDR: cidr.MustParseCIDR("fd00::1/64"), 191 }, 192 args: args{ 193 o: &Node{ 194 Name: "foo", 195 Cluster: "cluster-1", 196 IPv4HealthIP: net.ParseIP("1.1.1.1"), 197 IPv6HealthIP: net.ParseIP("fd00::1"), 198 ClusterID: 1, 199 Source: source.Kubernetes, 200 IPv4AllocCIDR: cidr.MustParseCIDR("1.1.1.1/24"), 201 IPv6AllocCIDR: cidr.MustParseCIDR("fd00::1/64"), 202 }, 203 }, 204 want: false, 205 }, 206 { 207 name: "test different IPv4AllocCIDR", 208 fields: fields{ 209 Name: "foo", 210 Cluster: "cluster-1", 211 IPv4HealthIP: net.ParseIP("1.1.1.1"), 212 IPv6HealthIP: net.ParseIP("fd00::1"), 213 ClusterID: 1, 214 Source: source.Kubernetes, 215 IPAddresses: []Address{{IP: net.ParseIP("1.1.1.1"), Type: addressing.NodeHostName}}, 216 IPv4AllocCIDR: cidr.MustParseCIDR("1.1.1.1/24"), 217 IPv6AllocCIDR: cidr.MustParseCIDR("fd00::1/64"), 218 }, 219 args: args{ 220 o: &Node{ 221 Name: "foo", 222 Cluster: "cluster-1", 223 IPv4HealthIP: net.ParseIP("1.1.1.1"), 224 IPv6HealthIP: net.ParseIP("fd00::1"), 225 ClusterID: 1, 226 Source: source.Kubernetes, 227 IPAddresses: []Address{{IP: net.ParseIP("1.1.1.0"), Type: addressing.NodeHostName}}, 228 IPv6AllocCIDR: cidr.MustParseCIDR("fd00::1/64"), 229 }, 230 }, 231 want: false, 232 }, 233 { 234 name: "test different IPv6AllocCIDR", 235 fields: fields{ 236 Name: "foo", 237 Cluster: "cluster-1", 238 IPv4HealthIP: net.ParseIP("1.1.1.1"), 239 IPv6HealthIP: net.ParseIP("fd00::1"), 240 ClusterID: 1, 241 Source: source.Kubernetes, 242 IPAddresses: []Address{{IP: net.ParseIP("1.1.1.1"), Type: addressing.NodeHostName}}, 243 IPv4AllocCIDR: cidr.MustParseCIDR("1.1.1.1/24"), 244 IPv6AllocCIDR: cidr.MustParseCIDR("fd00::1/64"), 245 }, 246 args: args{ 247 o: &Node{ 248 Name: "foo", 249 Cluster: "cluster-1", 250 IPv4HealthIP: net.ParseIP("1.1.1.1"), 251 IPv6HealthIP: net.ParseIP("fd00::1"), 252 ClusterID: 1, 253 Source: source.Kubernetes, 254 IPAddresses: []Address{{IP: net.ParseIP("1.1.1.0"), Type: addressing.NodeHostName}}, 255 IPv4AllocCIDR: cidr.MustParseCIDR("1.1.1.1/24"), 256 }, 257 }, 258 want: false, 259 }, 260 { 261 name: "test different name", 262 fields: fields{ 263 Name: "foo", 264 Cluster: "cluster-1", 265 IPv4HealthIP: net.ParseIP("1.1.1.1"), 266 IPv6HealthIP: net.ParseIP("fd00::1"), 267 ClusterID: 1, 268 Source: source.Kubernetes, 269 IPAddresses: []Address{{IP: net.ParseIP("1.1.1.1"), Type: addressing.NodeHostName}}, 270 IPv4AllocCIDR: cidr.MustParseCIDR("1.1.1.1/24"), 271 IPv6AllocCIDR: cidr.MustParseCIDR("fd00::1/64"), 272 }, 273 args: args{ 274 o: &Node{ 275 Cluster: "cluster-1", 276 IPv4HealthIP: net.ParseIP("1.1.1.1"), 277 IPv6HealthIP: net.ParseIP("fd00::1"), 278 ClusterID: 1, 279 Source: source.Kubernetes, 280 IPAddresses: []Address{{IP: net.ParseIP("1.1.1.0"), Type: addressing.NodeHostName}}, 281 IPv4AllocCIDR: cidr.MustParseCIDR("1.1.1.1/24"), 282 IPv6AllocCIDR: cidr.MustParseCIDR("fd00::1/64"), 283 }, 284 }, 285 want: false, 286 }, 287 } 288 for _, tt := range tests { 289 n := &Node{ 290 Name: tt.fields.Name, 291 Cluster: tt.fields.Cluster, 292 IPAddresses: tt.fields.IPAddresses, 293 IPv4AllocCIDR: tt.fields.IPv4AllocCIDR, 294 IPv6AllocCIDR: tt.fields.IPv6AllocCIDR, 295 IPv4HealthIP: tt.fields.IPv4HealthIP, 296 IPv6HealthIP: tt.fields.IPv6HealthIP, 297 ClusterID: tt.fields.ClusterID, 298 Source: tt.fields.Source, 299 } 300 c.Logf(tt.name) 301 got := n.PublicAttrEquals(tt.args.o) 302 c.Assert(got, Equals, tt.want) 303 } 304 }