Add few more tests

Author: kkumar

plugins/ipam/plugin_test.go

@@ -42,36 +42,15 @@ var _ = Describe("IPAM Plugin", func() {
 		err = os.WriteFile(testConfigPath, configData, 0644)
 		Expect(err).NotTo(HaveOccurred())
 
-		mac := machineWithIPAddressMACAddress
-		m, err := net.ParseMAC(mac)
-		Expect(err).NotTo(HaveOccurred())
-		i := net.ParseIP(linkLocalIPV6Prefix)
-		linkLocalIPV6Addr, err = eui64.ParseMAC(i, m)
-		Expect(err).NotTo(HaveOccurred())
+		ipv6, linkLocalIPV6Addr = createTestIPAMIP(machineWithIPAddressMACAddress, *ns)
+		Expect(ipv6).NotTo(BeNil())
+		Expect(linkLocalIPV6Addr).NotTo(BeNil())
 
-		sanitizedMAC := strings.Replace(mac, ":", "", -1)
-		ipv6Addr, err := ipamv1alpha1.IPAddrFromString(linkLocalIPV6Addr.String())
-		Expect(err).NotTo(HaveOccurred())
-		ipv6 = &ipamv1alpha1.IP{
-			ObjectMeta: metav1.ObjectMeta{
-				Namespace:    ns.Name,
-				GenerateName: "test-",
-				Labels: map[string]string{
-					"mac": sanitizedMAC,
-				},
-			},
-			Spec: ipamv1alpha1.IPSpec{
-				Subnet: corev1.LocalObjectReference{
-					Name: "foo",
-				},
-				IP: ipv6Addr,
-			},
-		}
 		Expect(k8sClientTest.Create(ctx, ipv6)).To(Succeed())
 		DeferCleanup(k8sClientTest.Delete, ipv6)
 
 		Eventually(UpdateStatus(ipv6, func() {
-			ipv6.Status.Reserved = ipv6Addr
+			ipv6.Status.Reserved = ipv6.Spec.IP
 		})).Should(Succeed())
 	})
 
@@ -150,85 +129,92 @@ var _ = Describe("IPAM Plugin", func() {
 		})
 
 		It("should successfully handle request", func() {
-			// //sanitizedMAC := strings.Replace(mac, ":", "", -1)
-			// ipv6Addr, _ := ipamv1alpha1.IPAddrFromString(linkLocalIPV6Addr.String())
-
-			// ipv6 := &ipamv1alpha1.IP{
-			// 	ObjectMeta: metav1.ObjectMeta{
-			// 		Namespace:    ns.Name,
-			// 		GenerateName: "test-",
-			// 	},
-			// 	Spec: ipamv1alpha1.IPSpec{
-			// 		Subnet: corev1.LocalObjectReference{
-			// 			Name: "foo",
-			// 		},
-			// 		IP: ipv6Addr,
-			// 	},
-			// }
-
-			// err3 := k8sClientTest.Create(context.TODO(), ipv6)
-			// Expect(err3).To(BeNil())
-
-			// createdSubnet := &ipamv1alpha1.Subnet{
-			// 	ObjectMeta: metav1.ObjectMeta{
-			// 		Name:      "foo",
-			// 		Namespace: ns.Name,
-			// 	},
-			// }
-
-			// err5 := k8sClientTest.Create(context.TODO(), createdSubnet)
-			// Expect(err5).To(BeNil())
-
-			// subnet := &ipamv1alpha1.Subnet{
-			// 	ObjectMeta: metav1.ObjectMeta{
-			// 		Name:      "foo",
-			// 		Namespace: ns.Name,
-			// 	},
-			// }
-			// existingSubnet := subnet.DeepCopy()
-			// err4 := k8sClientTest.Get(context.TODO(), client.ObjectKeyFromObject(subnet), existingSubnet)
-			// Expect(err4).To(BeNil())
-
-			//Expect(k8sClientTest.Create(context.TODO(), ipv6)).To(Succeed())
-			// clientset, err2 := ipam.NewForConfig(cfg)
-			// Expect(err2).NotTo(HaveOccurred())
-			// createdSubnet, err1 := clientset.IpamV1alpha1().Subnets(ns.Name).Create(context.TODO(), subnet, v1.CreateOptions{})
-			// Expect(err1).NotTo(HaveOccurred())
-			// Expect(createdSubnet).NotTo(BeNil())
-
-			//fmt.Printf("createdSubnet: %v", createdSubnet)
-
-			// mac, _ := net.ParseMAC(machineWithIPAddressMACAddress)
-			// ip := net.ParseIP(linkLocalIPV6Prefix)
-			// linkLocalIPV6Addr, _ := eui64.ParseMAC(ip, mac)
-
 			req, _ := dhcpv6.NewMessage()
 			req.MessageType = dhcpv6.MessageTypeRequest
 			relayedRequest, _ := dhcpv6.EncapsulateRelay(req, dhcpv6.MessageTypeRelayForward, net.IPv6loopback, linkLocalIPV6Addr)
 
 			stub, err := dhcpv6.NewMessage()
-			Expect(err).To(BeNil())
+			Expect(err).ToNot(HaveOccurred())
 			resp, stop := handler6(relayedRequest, stub)
 			Expect(stop).To(BeFalse())
 			Expect(resp).NotTo(BeNil())
 		})
 	})
 
 	Describe("K8s Client tests", func() {
-		It("should successfully match the subnet", func() {
-			k8sClient, err := NewK8sClient(ns.Name, []string{"foo"})
+		var (
+			linkLocalIPV6Addr net.IP
+			ipv6              *ipamv1alpha1.IP
+			k8sClient         *K8sClient
+		)
+
+		BeforeEach(func() {
+			By("creating an IPAM IP")
+			ipv6, linkLocalIPV6Addr = createTestIPAMIP(machineWithMacAddress, *ns)
+			Expect(ipv6).NotTo(BeNil())
+			Expect(linkLocalIPV6Addr).NotTo(BeNil())
+
+			k8sClient, err = NewK8sClient(ns.Name, []string{"foo"})
 			Expect(err).NotTo(HaveOccurred())
 			Expect(k8sClient).NotTo(BeNil())
+		})
 
+		It("should successfully match the subnet", func() {
 			subnet, err := k8sClient.getMatchingSubnet("foo", linkLocalIPV6Addr)
 			Expect(err).NotTo(HaveOccurred())
 			Expect(subnet).To(BeNil())
 		})
 
-		// It("should successfully match the subnet", func() {
+		It("should return error if subnet not matched", func() {
+			subnet, err := k8sClient.getMatchingSubnet("random-subnet", linkLocalIPV6Addr)
+			Expect(err).To(HaveOccurred())
+			Expect(subnet).To(BeNil())
+		})
+
+		It("should successfully return IPAM IP for machine with mac address", func() {
+			ip, err := k8sClient.prepareCreateIpamIP("foo", linkLocalIPV6Addr, net.HardwareAddr(machineWithIPAddressMACAddress))
+			Expect(err).NotTo(HaveOccurred())
+			Expect(ip).NotTo(BeNil())
+		})
+
+		It("should successfully create IPAM IP for machine with mac address", func() {
+			createIPError := k8sClient.doCreateIpamIP(ipv6)
+			Expect(createIPError).NotTo(HaveOccurred())
+		})
+
+		It("should successfully create IPAM IP for machine", func() {
+			createIPError := k8sClient.createIpamIP(linkLocalIPV6Addr, net.HardwareAddr(machineWithIPAddressMACAddress))
+			Expect(createIPError).NotTo(HaveOccurred())
+		})
+
+		// It("should return error, if create same IPAM IP for machine with same ip and same mac address", func() {
 		// 	err := k8sClient.doCreateIpamIP(ipv6)
 		// 	Expect(err).NotTo(HaveOccurred())
+		// 	//Expect(err.Error()).To(ContainSubstring("resourceVersion should not be set on objects to be created"))
+		// })
+
+		It("should return timeout error, if IPAM IP not deleted", func() {
+			err := k8sClient.waitForDeletion(ipv6)
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("timeout reached, IP not deleted"))
+		})
+
+		// It("should return timeout error, if IPAM IP not deleted", func() {
+		// 	ipv6 := createTestIPAMIP(machineWithMacAddress, *ns)
+
+		// 	createIPError := k8sClient.doCreateIpamIP(ipv6)
+		// 	Expect(createIPError).NotTo(HaveOccurred())
+
+		// 	err = k8sClientTest.Get(context.TODO(), client.ObjectKeyFromObject(ipv6), ipv6)
+		// 	Expect(err).NotTo(HaveOccurred())
+
+		// 	err = k8sClient.waitForDeletion(ipv6)
+		// 	Expect(err).To(HaveOccurred())
+		// 	err1 := k8sClientTest.Delete(context.TODO(), ipv6)
+		// 	Expect(err1).NotTo(HaveOccurred())
+		// 	Expect(err.Error()).To(ContainSubstring("timeout reached, IP not deleted"))
 		// })
+
 	})
 
 	Describe("Common tests", func() {
@@ -269,3 +255,31 @@ var _ = Describe("IPAM Plugin", func() {
 		})
 	})
 })
+
+func createTestIPAMIP(mac string, ns corev1.Namespace) (*ipamv1alpha1.IP, net.IP) {
+	m, err := net.ParseMAC(mac)
+	Expect(err).NotTo(HaveOccurred())
+	i := net.ParseIP(linkLocalIPV6Prefix)
+	linkLocalIPV6Addr, err := eui64.ParseMAC(i, m)
+	Expect(err).NotTo(HaveOccurred())
+
+	sanitizedMAC := strings.Replace(mac, ":", "", -1)
+	ipv6Addr, err := ipamv1alpha1.IPAddrFromString(linkLocalIPV6Addr.String())
+	Expect(err).NotTo(HaveOccurred())
+	ipv6 := &ipamv1alpha1.IP{
+		ObjectMeta: metav1.ObjectMeta{
+			Namespace: ns.Name,
+			Name:      "test-ip",
+			Labels: map[string]string{
+				"mac": sanitizedMAC,
+			},
+		},
+		Spec: ipamv1alpha1.IPSpec{
+			Subnet: corev1.LocalObjectReference{
+				Name: "foo",
+			},
+			IP: ipv6Addr,
+		},
+	}
+	return ipv6, linkLocalIPV6Addr
+}

plugins/ipam/suite_test.go

@@ -38,6 +38,7 @@ const (
 	linkLocalIPV6Prefix            = "fe80::"
 	subnetLabel                    = "subnet=dhcp"
 	machineWithIPAddressMACAddress = "11:22:33:44:55:66"
+	machineWithMacAddress          = "11:22:33:44:55:77"
 	privateIPV4Address             = "192.168.47.11"
 	ipamConfigFile                 = "config.yaml"
 )