Add tests

Author: carlotaarvela

cns/service/main_test.go

@@ -3,14 +3,22 @@ package main
 import (
 	"bytes"
 	"context"
+	"encoding/json"
 	"io"
 	"net/http"
+	"net/http/httptest"
+	"strings"
 	"testing"
+	"time"
 
 	"github.com/Azure/azure-container-networking/cns"
 	"github.com/Azure/azure-container-networking/cns/fakes"
 	"github.com/Azure/azure-container-networking/cns/logger"
+	"github.com/Azure/azure-container-networking/crd/multitenancy/api/v1alpha1"
 	"github.com/stretchr/testify/assert"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/client-go/rest"
 )
 
 // MockHTTPClient is a mock implementation of HTTPClient
@@ -69,3 +77,181 @@ func TestSendRegisterNodeRequest_StatusAccepted(t *testing.T) {
 
 	assert.Error(t, sendRegisterNodeRequest(ctx, mockClient, httpServiceFake, nodeRegisterReq, url))
 }
+
+func TestCreateOrUpdateNodeInfoCRD_WithTestifyMock_DirectCall(t *testing.T) {
+	// Create mock IMDS server
+	mockIMDSServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if strings.Contains(r.URL.Path, "/metadata/instance/compute") {
+			w.Header().Set("Content-Type", "application/json")
+			w.WriteHeader(http.StatusOK)
+			response := map[string]interface{}{
+				"vmId":              "test-vm-unique-id-12345",
+				"name":              "test-vm",
+				"resourceGroupName": "test-rg",
+			}
+			json.NewEncoder(w).Encode(response)
+			return
+		}
+		w.WriteHeader(http.StatusNotFound)
+	}))
+	defer mockIMDSServer.Close()
+
+	// Create mock CNS server
+	mockCNSServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if strings.Contains(r.URL.Path, "/homeaz") || strings.Contains(r.URL.Path, "homeaz") {
+			w.Header().Set("Content-Type", "application/json")
+			w.WriteHeader(http.StatusOK)
+			response := map[string]interface{}{
+				"ReturnCode": 0,
+				"Message":    "",
+				"HomeAzResponse": map[string]interface{}{
+					"IsSupported": true,
+					"HomeAz":      uint(2),
+				},
+			}
+			json.NewEncoder(w).Encode(response)
+			return
+		}
+		w.WriteHeader(http.StatusNotFound)
+	}))
+	defer mockCNSServer.Close()
+
+	// Set up HTTP transport to mock IMDS and CNS
+	originalTransport := http.DefaultTransport
+	defer func() { http.DefaultTransport = originalTransport }()
+
+	http.DefaultTransport = &mockTransport{
+		imdsServer: mockIMDSServer,
+		cnsServer:  mockCNSServer,
+		original:   originalTransport,
+	}
+
+	// Create a mock Kubernetes server that captures the NodeInfo being created
+	var capturedNodeInfo *v1alpha1.NodeInfo
+
+	mockK8sServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		// Handle specific API group discovery - multitenancy.acn.azure.com
+		if r.URL.Path == "/apis/multitenancy.acn.azure.com/v1alpha1" && r.Method == "GET" {
+			w.Header().Set("Content-Type", "application/json")
+			w.WriteHeader(http.StatusOK)
+			json.NewEncoder(w).Encode(map[string]interface{}{
+				"kind":         "APIResourceList",
+				"groupVersion": "multitenancy.acn.azure.com/v1alpha1",
+				"resources": []map[string]interface{}{
+					{
+						"name":         "nodeinfos",
+						"singularName": "nodeinfo",
+						"namespaced":   false,
+						"kind":         "NodeInfo",
+						"verbs":        []string{"create", "delete", "get", "list", "patch", "update", "watch"},
+					},
+				},
+			})
+			return
+		}
+
+		// Handle NodeInfo resource requests
+		if strings.Contains(r.URL.Path, "nodeinfos") || strings.Contains(r.URL.Path, "multitenancy") {
+			if r.Method == "POST" || r.Method == "PATCH" || r.Method == "PUT" {
+				body, _ := io.ReadAll(r.Body)
+
+				// Try to parse the NodeInfo from the request
+				var nodeInfo v1alpha1.NodeInfo
+				if err := json.Unmarshal(body, &nodeInfo); err == nil {
+					capturedNodeInfo = &nodeInfo
+				}
+
+				w.Header().Set("Content-Type", "application/json")
+				w.WriteHeader(http.StatusOK)
+				// Return the created NodeInfo
+				json.NewEncoder(w).Encode(map[string]interface{}{
+					"apiVersion": "multitenancy.acn.azure.com/v1alpha1",
+					"kind":       "NodeInfo",
+					"metadata": map[string]interface{}{
+						"name": "test-node",
+					},
+					"spec": map[string]interface{}{
+						"vmUniqueID": "test-vm-unique-id-12345",
+						"homeAZ":     "AZ02",
+					},
+				})
+				return
+			}
+
+			// Handle GET requests (checking if NodeInfo exists)
+			if r.Method == "GET" {
+				w.Header().Set("Content-Type", "application/json")
+				w.WriteHeader(http.StatusNotFound) // Simulate NodeInfo doesn't exist yet
+				json.NewEncoder(w).Encode(map[string]interface{}{
+					"kind":   "Status",
+					"status": "Failure",
+					"code":   404,
+				})
+				return
+			}
+		}
+
+		// Default success response for any other API calls
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusOK)
+		json.NewEncoder(w).Encode(map[string]interface{}{
+			"kind":   "Status",
+			"status": "Success",
+		})
+	}))
+	defer mockK8sServer.Close()
+
+	// Test the function with mocked dependencies
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	// Point to our mock Kubernetes server
+	restConfig := &rest.Config{
+		Host: mockK8sServer.URL,
+	}
+
+	node := &corev1.Node{
+		ObjectMeta: metav1.ObjectMeta{Name: "test-node"},
+	}
+
+	// Call the createOrUpdateNodeInfoCRD function
+	err := createOrUpdateNodeInfoCRD(ctx, restConfig, node)
+
+	// Verify the function succeeded
+	assert.NoError(t, err, "Function should succeed with mocked dependencies")
+
+	// Verify the captured values
+	assert.NotNil(t, capturedNodeInfo, "NodeInfo should have been captured from K8s API call")
+	if capturedNodeInfo != nil {
+		assert.Equal(t, "test-node", capturedNodeInfo.Name, "NodeInfo name should match")
+		assert.Equal(t, "test-vm-unique-id-12345", capturedNodeInfo.Spec.VMUniqueID, "VMUniqueID should be from IMDS")
+		assert.Equal(t, "AZ02", capturedNodeInfo.Spec.HomeAZ, "HomeAZ should be formatted from CNS response")
+	}
+}
+
+// mockTransport redirects HTTP requests to mock servers for testing.
+// It intercepts requests to IMDS and CNS endpoints and routes them to local test servers.
+type mockTransport struct {
+	imdsServer *httptest.Server
+	cnsServer  *httptest.Server
+	original   http.RoundTripper
+}
+
+func (m *mockTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+	// Redirect IMDS calls to mock IMDS server
+	if req.URL.Host == "169.254.169.254" {
+		req.URL.Scheme = "http"
+		req.URL.Host = strings.TrimPrefix(m.imdsServer.URL, "http://")
+		return m.original.RoundTrip(req)
+	}
+
+	// Redirect CNS calls to mock CNS server
+	if req.URL.Host == "localhost:10090" || strings.Contains(req.URL.Host, "10090") {
+		req.URL.Scheme = "http"
+		req.URL.Host = strings.TrimPrefix(m.cnsServer.URL, "http://")
+		return m.original.RoundTrip(req)
+	}
+
+	// All other calls go through original transport
+	return m.original.RoundTrip(req)
+}