add more unit tests

Author: LinuxSuRen

cmd/init.go

@@ -1,19 +1,20 @@
 package cmd
 
 import (
-	"github.com/linuxsuren/api-testing/pkg/exec"
+	fakeruntime "github.com/linuxsuren/go-fake-runtime"
 	"github.com/spf13/cobra"
 )
 
 type initOption struct {
+	execer        fakeruntime.Execer
 	kustomization string
 	waitNamespace string
 	waitResource  string
 }
 
 // createInitCommand returns the init command
-func createInitCommand() (cmd *cobra.Command) {
-	opt := &initOption{}
+func createInitCommand(execer fakeruntime.Execer) (cmd *cobra.Command) {
+	opt := &initOption{execer: execer}
 	cmd = &cobra.Command{
 		Use:    "init",
 		Long:   "Support to init Kubernetes cluster with kustomization, and wait it with command: kubectl wait",
@@ -30,13 +31,13 @@ func createInitCommand() (cmd *cobra.Command) {
 
 func (o *initOption) runE(cmd *cobra.Command, args []string) (err error) {
 	if o.kustomization != "" {
-		if err = exec.RunCommand("kubectl", "apply", "-k", o.kustomization, "--wait=true"); err != nil {
+		if err = o.execer.RunCommand("kubectl", "apply", "-k", o.kustomization, "--wait=true"); err != nil {
 			return
 		}
 	}
 
 	if o.waitNamespace != "" && o.waitResource != "" {
-		if err = exec.RunCommand("kubectl", "wait", "-n", o.waitNamespace, o.waitResource, "--for", "condition=Available=True", "--timeout=900s"); err != nil {
+		if err = o.execer.RunCommand("kubectl", "wait", "-n", o.waitNamespace, o.waitResource, "--for", "condition=Available=True", "--timeout=900s"); err != nil {
 			return
 		}
 	}

cmd/root.go

@@ -6,6 +6,7 @@ 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
@@ -16,9 +17,10 @@ func NewRootCmd(execer fakeruntime.Execer) (c *cobra.Command) {
 	}
 	c.SetOut(os.Stdout)
 	c.Version = version.GetVersion()
-	c.AddCommand(createInitCommand(),
+	gRPCServer := grpc.NewServer()
+	c.AddCommand(createInitCommand(execer),
 		createRunCommand(), createSampleCmd(),
-		createServerCmd(), createJSONSchemaCmd(),
+		createServerCmd(gRPCServer), createJSONSchemaCmd(),
 		createServiceCommand(execer))
 	return
 }

cmd/root_test.go

@@ -6,6 +6,7 @@ import (
 	"github.com/stretchr/testify/assert"
 
 	atesting "github.com/linuxsuren/api-testing/pkg/testing"
+	exec "github.com/linuxsuren/go-fake-runtime"
 )
 
 func Test_setRelativeDir(t *testing.T) {
@@ -43,10 +44,15 @@ func TestCreateRunCommand(t *testing.T) {
 	cmd := createRunCommand()
 	assert.Equal(t, "run", cmd.Use)
 
-	init := createInitCommand()
+	init := createInitCommand(exec.FakeExecer{})
 	assert.Equal(t, "init", init.Use)
 
-	server := createServerCmd()
+	server := createServerCmd(&fakeGRPCServer{})
 	assert.NotNil(t, server)
 	assert.Equal(t, "server", server.Use)
+
+	root := NewRootCmd(exec.FakeExecer{})
+	root.SetArgs([]string{"init", "-k=demo.yaml", "--wait-namespace", "demo", "--wait-resource", "demo"})
+	err := root.Execute()
+	assert.Nil(t, err)
 }

cmd/server.go

@@ -11,8 +11,8 @@ import (
 	"google.golang.org/grpc"
 )
 
-func createServerCmd() (c *cobra.Command) {
-	opt := &serverOption{}
+func createServerCmd(gRPCServer gRPCServer) (c *cobra.Command) {
+	opt := &serverOption{gRPCServer: gRPCServer}
 	c = &cobra.Command{
 		Use:   "server",
 		Short: "Run as a server mode",
@@ -25,6 +25,7 @@ func createServerCmd() (c *cobra.Command) {
 }
 
 type serverOption struct {
+	gRPCServer gRPCServer
 	port       int
 	printProto bool
 }
@@ -43,9 +44,26 @@ func (o *serverOption) runE(cmd *cobra.Command, args []string) (err error) {
 		return
 	}
 
-	s := grpc.NewServer()
+	s := o.gRPCServer
 	server.RegisterRunnerServer(s, server.NewRemoteServer())
 	log.Printf("server listening at %v", lis.Addr())
 	s.Serve(lis)
 	return
 }
+
+type gRPCServer interface {
+	Serve(lis net.Listener) error
+	grpc.ServiceRegistrar
+}
+
+type fakeGRPCServer struct {
+}
+
+// Serve is a fake method
+func (s *fakeGRPCServer) Serve(net.Listener) error {
+	return nil
+}
+
+// RegisterService is a fake method
+func (s *fakeGRPCServer) RegisterService(desc *grpc.ServiceDesc, impl interface{}) {
+}

cmd/server_test.go

@@ -38,4 +38,8 @@ func TestPrintProto(t *testing.T) {
 			tt.verify(t, buf, err)
 		})
 	}
+
+	server := createServerCmd(&fakeGRPCServer{})
+	err := server.Execute()
+	assert.Nil(t, err)
 }

cmd/service.go

@@ -1,3 +1,4 @@
+// Package cmd provides a service command
 package cmd
 
 import (

pkg/runner/simple.go

@@ -17,8 +17,8 @@ import (
 	"github.com/andreyvit/diff"
 	"github.com/antonmedv/expr"
 	"github.com/antonmedv/expr/vm"
-	"github.com/linuxsuren/api-testing/pkg/exec"
 	"github.com/linuxsuren/api-testing/pkg/testing"
+	fakeruntime "github.com/linuxsuren/go-fake-runtime"
 	unstructured "github.com/linuxsuren/unstructured/pkg"
 	"github.com/xeipuuv/gojsonschema"
 )
@@ -78,6 +78,7 @@ type TestCaseRunner interface {
 	WithOutputWriter(io.Writer) TestCaseRunner
 	WithWriteLevel(level string) TestCaseRunner
 	WithTestReporter(TestReporter) TestCaseRunner
+	WithExecer(fakeruntime.Execer) TestCaseRunner
 }
 
 // ReportRecord represents the raw data of a HTTP request
@@ -157,14 +158,16 @@ type simpleTestCaseRunner struct {
 	testReporter TestReporter
 	writer       io.Writer
 	log          LevelWriter
+	execer       fakeruntime.Execer
 }
 
 // NewSimpleTestCaseRunner creates the instance of the simple test case runner
 func NewSimpleTestCaseRunner() TestCaseRunner {
 	runner := &simpleTestCaseRunner{}
 	return runner.WithOutputWriter(io.Discard).
 		WithWriteLevel("info").
-		WithTestReporter(NewDiscardTestReporter())
+		WithTestReporter(NewDiscardTestReporter()).
+		WithExecer(fakeruntime.DefaultExecer{})
 }
 
 // RunTestCase is the main entry point of a test case
@@ -179,16 +182,14 @@ func (r *simpleTestCaseRunner) RunTestCase(testcase *testing.TestCase, dataConte
 		r.testReporter.PutRecord(rr)
 	}(record)
 
-	if err = doPrepare(testcase); err != nil {
+	if err = r.doPrepare(testcase); err != nil {
 		err = fmt.Errorf("failed to prepare, error: %v", err)
 		return
 	}
 
 	defer func() {
 		if testcase.Clean.CleanPrepare {
-			if err = doCleanPrepare(testcase); err != nil {
-				return
-			}
+			err = r.doCleanPrepare(testcase)
 		}
 	}()
 
@@ -363,29 +364,29 @@ func (r *simpleTestCaseRunner) WithTestReporter(reporter TestReporter) TestCaseR
 	return r
 }
 
-// Deprecated
-// RunTestCase runs the test case.
-func RunTestCase(testcase *testing.TestCase, dataContext interface{}, ctx context.Context) (output interface{}, err error) {
-	return NewSimpleTestCaseRunner().WithOutputWriter(os.Stdout).RunTestCase(testcase, dataContext, ctx)
+// WithExecer sets the execer
+func (r *simpleTestCaseRunner) WithExecer(execer fakeruntime.Execer) TestCaseRunner {
+	r.execer = execer
+	return r
 }
 
-func doPrepare(testcase *testing.TestCase) (err error) {
+func (r *simpleTestCaseRunner) doPrepare(testcase *testing.TestCase) (err error) {
 	for i := range testcase.Prepare.Kubernetes {
 		item := testcase.Prepare.Kubernetes[i]
 
-		if err = exec.RunCommand("kubectl", "apply", "-f", item); err != nil {
+		if err = r.execer.RunCommand("kubectl", "apply", "-f", item); err != nil {
 			return
 		}
 	}
 	return
 }
 
-func doCleanPrepare(testcase *testing.TestCase) (err error) {
+func (r *simpleTestCaseRunner) doCleanPrepare(testcase *testing.TestCase) (err error) {
 	count := len(testcase.Prepare.Kubernetes)
 	for i := count - 1; i >= 0; i-- {
 		item := testcase.Prepare.Kubernetes[i]
 
-		if err = exec.RunCommand("kubectl", "delete", "-f", item); err != nil {
+		if err = r.execer.RunCommand("kubectl", "delete", "-f", item); err != nil {
 			return
 		}
 	}

pkg/runner/simple_test.go

@@ -5,23 +5,37 @@ import (
 	"context"
 	"errors"
 	"net/http"
+	"os"
 	"testing"
 
 	_ "embed"
 
 	"github.com/h2non/gock"
 	atest "github.com/linuxsuren/api-testing/pkg/testing"
+	fakeruntime "github.com/linuxsuren/go-fake-runtime"
 	"github.com/stretchr/testify/assert"
 )
 
 func TestTestCase(t *testing.T) {
 	tests := []struct {
 		name     string
+		execer   fakeruntime.Execer
 		testCase *atest.TestCase
 		ctx      interface{}
 		prepare  func()
 		verify   func(t *testing.T, output interface{}, err error)
 	}{{
+		name: "failed during the prepare stage",
+		testCase: &atest.TestCase{
+			Prepare: atest.Prepare{
+				Kubernetes: []string{"demo.yaml"},
+			},
+		},
+		execer: fakeruntime.FakeExecer{ExpectError: errors.New("fake")},
+		verify: func(t *testing.T, output interface{}, err error) {
+			assert.NotNil(t, err)
+		},
+	}, {
 		name: "normal, response is map",
 		testCase: &atest.TestCase{
 			Request: atest.Request{
@@ -44,7 +58,14 @@ func TestTestCase(t *testing.T) {
 					`data.name == "linuxsuren"`,
 				},
 			},
+			Prepare: atest.Prepare{
+				Kubernetes: []string{"demo.yaml"},
+			},
+			Clean: atest.Clean{
+				CleanPrepare: true,
+			},
 		},
+		execer: fakeruntime.FakeExecer{},
 		prepare: func() {
 			gock.New("http://localhost").
 				Get("/foo").
@@ -370,7 +391,11 @@ func TestTestCase(t *testing.T) {
 			if tt.prepare != nil {
 				tt.prepare()
 			}
-			output, err := RunTestCase(tt.testCase, tt.ctx, context.TODO())
+			runner := NewSimpleTestCaseRunner().WithOutputWriter(os.Stdout)
+			if tt.execer != nil {
+				runner.WithExecer(tt.execer)
+			}
+			output, err := runner.RunTestCase(tt.testCase, tt.ctx, context.TODO())
 			tt.verify(t, output, err)
 		})
 	}