Add IPv6 unittests for cluster setup

src/k8s/pkg/k8sd/setup/auth-token-webhook.conf

@@ -0,0 +1,17 @@
+apiVersion: v1
+kind: Config
+clusters:
+  - name: k8s-token-auth-service
+    cluster:
+      certificate-authority: "cluster.crt"
+      tls-server-name: 127.0.0.1
+      server: "https://auth-webhook.url"
+current-context: webhook
+contexts:
+- context:
+    cluster: k8s-token-auth-service
+    user: k8s-apiserver
+  name: webhook
+users:
+  - name: k8s-apiserver
+    user: {}

src/k8s/pkg/k8sd/setup/k8s_apiserver_proxy_test.go

@@ -130,4 +130,30 @@ func TestK8sApiServerProxy(t *testing.T) {
 		// Compare the expected endpoints with those in the file
 		g.Expect(config.Endpoints).To(Equal(endpoints))
 	})
+
+	t.Run("IPv6", func(t *testing.T) {
+		g := NewWithT(t)
+
+		// Create a mock snap
+		s := mustSetupSnapAndDirectories(t, setKubeletMock)
+		s.Mock.Hostname = "dev"
+
+		// Call the kubelet control plane setup function
+		g.Expect(setup.K8sAPIServerProxy(s, nil, "[2001:db8::]", nil)).To(Succeed())
+
+		tests := []struct {
+			key         string
+			expectedVal string
+		}{
+			{key: "--listen", expectedVal: "[2001:db8::]:6443"},
+		}
+		for _, tc := range tests {
+			t.Run(tc.key, func(t *testing.T) {
+				g := NewWithT(t)
+				val, err := snaputil.GetServiceArgument(s, "k8s-apiserver-proxy", tc.key)
+				g.Expect(err).ToNot(HaveOccurred())
+				g.Expect(tc.expectedVal).To(Equal(val))
+			})
+		}
+	})
 }

src/k8s/pkg/k8sd/setup/kube_apiserver_test.go

@@ -245,4 +245,31 @@ func TestKubeAPIServer(t *testing.T) {
 		g.Expect(err).To(HaveOccurred())
 		g.Expect(err).To(MatchError(ContainSubstring("unsupported datastore")))
 	})
+
+	t.Run("IPv6", func(t *testing.T) {
+		g := NewWithT(t)
+
+		// Create a mock snap
+		s := mustSetupSnapAndDirectories(t, setKubeletMock)
+		s.Mock.Hostname = "dev"
+
+		// Call the kubelet control plane setup function
+		g.Expect(setup.KubeAPIServer(s, net.ParseIP("2001:db8::"), "fd98::/108", "https://auth-webhook.url", false, types.Datastore{Type: utils.Pointer("k8s-dqlite")}, "Node,RBAC", nil)).To(Succeed())
+
+		tests := []struct {
+			key         string
+			expectedVal string
+		}{
+			{key: "--advertise-address", expectedVal: "2001:db8::"},
+			{key: "--service-cluster-ip-range", expectedVal: "fd98::/108"},
+		}
+		for _, tc := range tests {
+			t.Run(tc.key, func(t *testing.T) {
+				g := NewWithT(t)
+				val, err := snaputil.GetServiceArgument(s, "kube-apiserver", tc.key)
+				g.Expect(err).ToNot(HaveOccurred())
+				g.Expect(tc.expectedVal).To(Equal(val))
+			})
+		}
+	})
 }

src/k8s/pkg/k8sd/setup/kube_proxy_test.go

@@ -109,4 +109,31 @@ func TestKubeProxy(t *testing.T) {
 		g.Expect(err).To(BeNil())
 		g.Expect(val).To(BeEmpty())
 	})
+
+	t.Run("IPv6", func(t *testing.T) {
+		g := NewWithT(t)
+
+		// Create a mock snap
+		s := mustSetupSnapAndDirectories(t, setKubeletMock)
+		s.Mock.Hostname = "dev"
+
+		// Call the kubelet control plane setup function
+		g.Expect(setup.KubeProxy(context.Background(), s, "dev", "fd98::/108", "[::1]", nil)).To(BeNil())
+
+		tests := []struct {
+			key         string
+			expectedVal string
+		}{
+			{key: "--cluster-cidr", expectedVal: "fd98::/108"},
+			{key: "--healthz-bind-address", expectedVal: "[::1]:10256"},
+		}
+		for _, tc := range tests {
+			t.Run(tc.key, func(t *testing.T) {
+				g := NewWithT(t)
+				val, err := snaputil.GetServiceArgument(s, "kube-proxy", tc.key)
+				g.Expect(err).ToNot(HaveOccurred())
+				g.Expect(tc.expectedVal).To(Equal(val))
+			})
+		}
+	})
 }

src/k8s/pkg/k8sd/setup/kubelet.go

@@ -81,7 +81,7 @@ func kubelet(snap snap.Snap, hostname string, nodeIP net.IP, clusterDNS string,
 		args["--cluster-domain"] = clusterDomain
 	}
 	if nodeIP != nil && !nodeIP.IsLoopback() {
-		args["--node-ip"] = utils.ToIPString(nodeIP)
+		args["--node-ip"] = nodeIP.String()
 	}
 	if _, err := snaputil.UpdateServiceArguments(snap, "kubelet", args, nil); err != nil {
 		return fmt.Errorf("failed to render arguments file: %w", err)

src/k8s/pkg/k8sd/setup/kubelet_test.go

@@ -400,4 +400,31 @@ func TestKubelet(t *testing.T) {
 		g.Expect(err).To(BeNil())
 		g.Expect(val).To(BeEmpty())
 	})
+
+	t.Run("IPv6", func(t *testing.T) {
+		g := NewWithT(t)
+
+		// Create a mock snap
+		s := mustSetupSnapAndDirectories(t, setKubeletMock)
+		s.Mock.Hostname = "dev"
+
+		// Call the kubelet control plane setup function
+		g.Expect(setup.KubeletControlPlane(s, "dev", net.ParseIP("2001:db8::"), "2001:db8::1", "test-cluster.local", "provider", nil, nil)).To(Succeed())
+
+		tests := []struct {
+			key         string
+			expectedVal string
+		}{
+			{key: "--cluster-dns", expectedVal: "2001:db8::1"},
+			{key: "--node-ip", expectedVal: "2001:db8::"},
+		}
+		for _, tc := range tests {
+			t.Run(tc.key, func(t *testing.T) {
+				g := NewWithT(t)
+				val, err := snaputil.GetServiceArgument(s, "kubelet", tc.key)
+				g.Expect(err).ToNot(HaveOccurred())
+				g.Expect(tc.expectedVal).To(Equal(val))
+			})
+		}
+	})
 }