Go 中模拟 Kubernetes 客户端进行单元测试

是的，我们可以模仿 K8s Client！

编写单元测试一直是开发人员的痛苦。这样做的主要原因是，通常，单元测试（功能单元测试）不得使用应用程序的任何物理组件/运行实例。例如，API 的 SDK 的单元测试不应该有 API 的任何运行实例。这就是为什么模拟应用程序实例变得至关重要，这也是诀窍！

在本文中，我们将了解如何使用​​client-go​​ 包中的 fake（伪造的） clientset （客户端集）模拟 Kubernetes 客户端。让我们开始吧！

创建一个名为​​client​​​和一个名为​​client.go​​​它定义了一个名为​​Client​​​持有 Kubernetes​​Clientset​​.

Kubernetes ​​Clientset​​

• 包含组的客户端（clients for groups）
• 是实现了 Kubernetes 接口​​Interface​​的 struct
• ​​NewForConfig()​​​是 Kubernetes ​​Interface​​ 接口的构造函数，返回 Clientset 对象

继续，让我们在​​client.go​​​中定义一个被称作​​Client​​的 public struct

// Client is the struct to hold the Kubernetes Clientset
type Client struct {
  Clientset kubernetes.Interface
}

创建一个名为 ​​CreatePod​​​ 的方法，该方法是 ​​Client​​​ 结构的方法，用来在给定的 namespace（名称空间）中创建 ​​pods​​​，如同 ​​Client.go​​ 文件中所示：

// CreatePod method creates pod in the cluster referred by the Client
func (c Client) CreatePod(pod *v1.Pod) (*v1.Pod, error) {
  pod, err := c.Clientset.CoreV1().Pods(pod.Namespace).Create(context.TODO(), pod, metav1.CreateOptions{})
  if err != nil {
    klog.Errorf("Error occured while creating pod %s: %s", pod.Name, err.Error())
    return nil, err
  }

  klog.Infof("Pod %s is succesfully created", pod.Name)
  return pod, nil
}

完整的​​client.go​​文件看起来像这样：

package client

import (
  "context"

  v1 "k8s.io/api/core/v1"
  metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
  "k8s.io/client-go/kubernetes"
  "k8s.io/klog/v2"
)

type Client struct {
  Clientset kubernetes.Interface
}

func (c Client) CreatePod(pod *v1.Pod) (*v1.Pod, error) {
  pod, err := c.Clientset.CoreV1().Pods(pod.Namespace).Create(context.TODO(), pod, metav1.CreateOptions{})
  if err != nil {
    klog.Errorf("Error occured while creating pod %s: %s", pod.Name, err.Error())
    return nil, err
  }

  klog.Infof("Pod %s is succesfully created", pod.Name)
  return pod, nil
}

现在，让我们实现一个​​main.go​​​调用上述​​CreatePod​​方法。为此，我们需要

• 建立​​clientset​​

kubeconfig = "<path to kubeconfig file>"

config, err := clientcmd.BuildConfigFromFlags("", kubeconfig)
if err != nil {
    panic(err.Error())
}

clientset, err := kubernetes.NewForConfig(config)
if err != nil {
    panic(err.Error())
}
view raw

• 加载​​Client​​结构

client := client.Client{
    Clientset: clientset,
}

• 定义一个​​pod​​资源对象

pod := &v1.Pod{
    TypeMeta: metav1.TypeMeta{
      Kind:       "Pod",
      APIVersion: "v1",
    },
    ObjectMeta: metav1.ObjectMeta{
      Name:      "test-pod",
      Namespace: "default",
    },
    Spec: v1.PodSpec{
      Containers: []v1.Container{
        {
          Name:            "nginx",
          Image:           "nginx",
          ImagePullPolicy: "Always",
        },
      },
    },
  }

• 对​​client​​​对象的​​CreatePod​​方法进行调用

pod, err = client.CreatePod(pod)

if err != nil {
  fmt.Printf("%s", err)
}
klog.Infof("Pod %s has been successfully created", pod.Name)

完整的​​main.go​​文件看起来像这样：

package main

import (
  "fmt"

  client "github.com/kubernetes-sdk-for-go-101/pkg/client"
  v1 "k8s.io/api/core/v1"
  metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
  "k8s.io/client-go/kubernetes"
  "k8s.io/client-go/tools/clientcmd"
  "k8s.io/klog/v2"
)

func main() {

  kubeconfig := "<path to kubeconfig file>"

  config, err := clientcmd.BuildConfigFromFlags("", kubeconfig)
  if err != nil {
    panic(err.Error())
  }

  clientset, err := kubernetes.NewForConfig(config)
  if err != nil {
    panic(err.Error())
  }

  client := client.Client{
    Clientset: clientset,
  }

  pod := &v1.Pod{
    TypeMeta: metav1.TypeMeta{
      Kind:       "Pod",
      APIVersion: "v1",
    },
    ObjectMeta: metav1.ObjectMeta{
      Name:      "test-pod",
      Namespace: "default",
    },
    Spec: v1.PodSpec{
      Containers: []v1.Container{
        {
          Name:            "nginx",
          Image:           "nginx",
          ImagePullPolicy: "Always",
        },
      },
    },
  }

  pod, err = client.CreatePod(pod)
  if err != nil {
    fmt.Printf("%s", err)
  }
  klog.Infof("Pod %s has been successfully created", pod.Name)
}

当我们对一个正在运行的集群运行 main.go 文件时，我们最终会在默认名称空间中创建一个名为 test-pod 的 pod。

现在，让我们使用 Go 的​​testing​​​包编写一个单元测试。在这里，为了创建 Kubernetes ​​Clientset​​​，我们使用 ​​client-go/kubernetes​​​包中的​​fake​​​ 包的​​NewSimpleClientSet()​​​构造函数，而不是​​NewForConfig()​​构造函数。

有什么区别？

​​NewForConfig()​​​构造函数返回实际​​ClientSet​​​它具有每个 Kubernetes 组的客户端并在实际集群上运行。 然而，​​NewSimpleClientSet()​​构造函数返回将使用提供的对象进行响应的客户端集。它由一个非常简单的对象跟踪器支持，该跟踪器按原样处理创建、更新和删除，而不应用任何验证和默认值。

这里需要注意的是​​fake​​​包中的​​Clientset​​ 也实现了 Kubernetes 接口。旨在嵌入到结构中以获得默认实现。这使得仅伪造您想要测试的方法变得更加容易。

我们​​main_test.go​​看起来像这样：

package main

import (
  "fmt"
  "testing"

  client "github.com/kubernetes-sdk-for-go-101/pkg/client"
  v1 "k8s.io/api/core/v1"
  metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
  testclient "k8s.io/client-go/kubernetes/fake"
)

func TestCreatePod(t *testing.T) {
  var client client.Client
  client.Clientset = testclient.NewSimpleClientset()

  pod := &v1.Pod{
    TypeMeta: metav1.TypeMeta{
      Kind:       "Pod",
      APIVersion: "v1",
    },
    ObjectMeta: metav1.ObjectMeta{
      Name:      "test-pod",
      Namespace: "default",
    },
    Spec: v1.PodSpec{
      Containers: []v1.Container{
        {
          Name:            "nginx",
          Image:           "nginx",
          ImagePullPolicy: "Always",
        },
      },
    },
  }

  _, err := client.CreatePod(pod)
  if err != nil {
    fmt.Print(err.Error())
  }

}

现在，如果我们使用 ​​go test​​​ 命令运行这个测试文件，我们将成功地执行 ​​CreatePod()​​​方法，即使没有对任何正在运行的 K8s 集群运行这个方法，并且通过模仿 ​​Get ()​​ 调用返回作为参数发送给它的相同对象。输出结果如图所示

go test
I0520 00:02:03.789351   23893 pod.go:23] Pod test-pod is succesfully created
PASS
ok      github.com/kubernetes-sdk-for-go-101    0.681s

您可以将本文作为参考，并以此为基础，为您使用 Kubernetes ​​client-go​​ 的应用程序构建测试框架或单元测试包。