feat: support verify against Kubernetes resources (#41)

* feat: support check the response againt k8s

* feat: support all the CRDs

* feat: support to verify fields

* add more unit tests

Author: LinuxSuRen

Makefile

@@ -10,6 +10,10 @@ run-image:
 	docker run ghcr.io/linuxsuren/api-testing:dev
 copy: build
 	sudo cp bin/atest /usr/local/bin/
+copy-restart:
+	atest service stop
+	make copy
+	atest service restart
 test:
 	go test ./... -cover -v -coverprofile=coverage.out
 	go tool cover -func=coverage.out

README.md

@@ -8,6 +8,7 @@ This is a API testing tool.
 
 *   Response Body fields equation check
 *   Response Body [eval](https://expr.medv.io/)
+*   Verify the Kubernetes resources
 *   Validate the response body with [JSON schema](https://json-schema.org/)
 *   Output reference between TestCase
 *   Run in server mode, and provide the gRPC endpoint
@@ -62,6 +63,15 @@ The following fields are templated with [sprig](http://masterminds.github.io/spr
 *   Request Body
 *   Request Header
 
+## Verify against Kubernetes
+
+It could verify any kinds of Kubernetes resources. Please set the environment variables before using it:
+
+*   `KUBERNETES_SERVER`
+*   `KUBERNETES_TOKEN`
+
+See also the [example](sample/kubernetes.yaml).
+
 ## TODO
 
 *   Reduce the size of context

cmd/jsonschema_test.go

@@ -11,7 +11,7 @@ import (
 )
 
 func TestJSONSchemaCmd(t *testing.T) {
-	c := cmd.NewRootCmd(fakeruntime.FakeExecer{ExpectOS: "linux"})
+	c := cmd.NewRootCmd(fakeruntime.FakeExecer{ExpectOS: "linux"}, cmd.NewFakeGRPCServer())
 
 	buf := new(bytes.Buffer)
 	c.SetOut(buf)

cmd/root.go

@@ -6,18 +6,16 @@ import (
 	"github.com/linuxsuren/api-testing/pkg/version"
 	fakeruntime "github.com/linuxsuren/go-fake-runtime"
 	"github.com/spf13/cobra"
-	"google.golang.org/grpc"
 )
 
 // NewRootCmd creates the root command
-func NewRootCmd(execer fakeruntime.Execer) (c *cobra.Command) {
+func NewRootCmd(execer fakeruntime.Execer, gRPCServer gRPCServer) (c *cobra.Command) {
 	c = &cobra.Command{
 		Use:   "atest",
 		Short: "API testing tool",
 	}
 	c.SetOut(os.Stdout)
 	c.Version = version.GetVersion()
-	gRPCServer := grpc.NewServer()
 	c.AddCommand(createInitCommand(execer),
 		createRunCommand(), createSampleCmd(),
 		createServerCmd(gRPCServer), createJSONSchemaCmd(),

cmd/root_test.go

@@ -51,7 +51,7 @@ func TestCreateRunCommand(t *testing.T) {
 	assert.NotNil(t, server)
 	assert.Equal(t, "server", server.Use)
 
-	root := NewRootCmd(exec.FakeExecer{})
+	root := NewRootCmd(exec.FakeExecer{}, NewFakeGRPCServer())
 	root.SetArgs([]string{"init", "-k=demo.yaml", "--wait-namespace", "demo", "--wait-resource", "demo"})
 	err := root.Execute()
 	assert.Nil(t, err)

cmd/run_test.go

@@ -104,7 +104,7 @@ func TestRunCommand(t *testing.T) {
 }
 
 func TestRootCmd(t *testing.T) {
-	c := NewRootCmd(fakeruntime.FakeExecer{ExpectOS: "linux"})
+	c := NewRootCmd(fakeruntime.FakeExecer{ExpectOS: "linux"}, NewFakeGRPCServer())
 	assert.NotNil(t, c)
 	assert.Equal(t, "atest", c.Use)
 }

cmd/sample_test.go

@@ -11,7 +11,7 @@ import (
 )
 
 func TestSampleCmd(t *testing.T) {
-	c := cmd.NewRootCmd(fakeruntime.FakeExecer{ExpectOS: "linux"})
+	c := cmd.NewRootCmd(fakeruntime.FakeExecer{ExpectOS: "linux"}, cmd.NewFakeGRPCServer())
 
 	buf := new(bytes.Buffer)
 	c.SetOut(buf)

cmd/server.go

@@ -59,6 +59,11 @@ type gRPCServer interface {
 type fakeGRPCServer struct {
 }
 
+// NewFakeGRPCServer creates a fake gRPC server
+func NewFakeGRPCServer() gRPCServer {
+	return &fakeGRPCServer{}
+}
+
 // Serve is a fake method
 func (s *fakeGRPCServer) Serve(net.Listener) error {
 	return nil

cmd/server_test.go

@@ -27,19 +27,21 @@ func TestPrintProto(t *testing.T) {
 		verify: func(t *testing.T, buf *bytes.Buffer, err error) {
 			assert.NotNil(t, err)
 		},
+	}, {
+		name: "random port",
+		args: []string{"server", "-p=0"},
+		verify: func(t *testing.T, buf *bytes.Buffer, err error) {
+			assert.Nil(t, err)
+		},
 	}}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			buf := new(bytes.Buffer)
-			root := NewRootCmd(fakeruntime.FakeExecer{ExpectOS: "linux"})
+			root := NewRootCmd(fakeruntime.FakeExecer{ExpectOS: "linux"}, &fakeGRPCServer{})
 			root.SetOut(buf)
 			root.SetArgs(tt.args)
 			err := root.Execute()
 			tt.verify(t, buf, err)
 		})
 	}
-
-	server := createServerCmd(&fakeGRPCServer{})
-	err := server.Execute()
-	assert.Nil(t, err)
 }

cmd/service_test.go

@@ -10,12 +10,12 @@ import (
 )
 
 func TestService(t *testing.T) {
-	root := NewRootCmd(fakeruntime.FakeExecer{ExpectOS: "linux"})
+	root := NewRootCmd(fakeruntime.FakeExecer{ExpectOS: "linux"}, NewFakeGRPCServer())
 	root.SetArgs([]string{"service", "fake"})
 	err := root.Execute()
 	assert.NotNil(t, err)
 
-	notLinux := NewRootCmd(fakeruntime.FakeExecer{ExpectOS: "fake"})
+	notLinux := NewRootCmd(fakeruntime.FakeExecer{ExpectOS: "fake"}, NewFakeGRPCServer())
 	notLinux.SetArgs([]string{"service", "--action", "install"})
 	err = notLinux.Execute()
 	assert.NotNil(t, err)
@@ -26,7 +26,7 @@ func TestService(t *testing.T) {
 		os.RemoveAll(tmpFile.Name())
 	}()
 
-	targetScript := NewRootCmd(fakeruntime.FakeExecer{ExpectOS: "linux"})
+	targetScript := NewRootCmd(fakeruntime.FakeExecer{ExpectOS: "linux"}, NewFakeGRPCServer())
 	targetScript.SetArgs([]string{"service", "--action", "install", "--script-path", tmpFile.Name()})
 	err = targetScript.Execute()
 	assert.Nil(t, err)
@@ -58,7 +58,7 @@ func TestService(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			buf := new(bytes.Buffer)
-			normalRoot := NewRootCmd(fakeruntime.FakeExecer{ExpectOS: "linux", ExpectOutput: tt.expectOutput})
+			normalRoot := NewRootCmd(fakeruntime.FakeExecer{ExpectOS: "linux", ExpectOutput: tt.expectOutput}, NewFakeGRPCServer())
 			normalRoot.SetOut(buf)
 			normalRoot.SetArgs([]string{"service", "--action", tt.action})
 			err = normalRoot.Execute()

main.go

@@ -5,10 +5,12 @@ import (
 
 	"github.com/linuxsuren/api-testing/cmd"
 	exec "github.com/linuxsuren/go-fake-runtime"
+	"google.golang.org/grpc"
 )
 
 func main() {
-	c := cmd.NewRootCmd(exec.DefaultExecer{})
+	gRPCServer := grpc.NewServer()
+	c := cmd.NewRootCmd(exec.DefaultExecer{}, gRPCServer)
 	if err := c.Execute(); err != nil {
 		os.Exit(1)
 	}