feat: support running before and after jobs with API request

Author: LinuxSuRen

cmd/root_test.go

@@ -5,41 +5,9 @@ import (
 
 	"github.com/stretchr/testify/assert"
 
-	atesting "github.com/linuxsuren/api-testing/pkg/testing"
 	exec "github.com/linuxsuren/go-fake-runtime"
 )
 
-func TestSetRelativeDir(t *testing.T) {
-	type args struct {
-		configFile string
-		testcase   *atesting.TestCase
-	}
-	tests := []struct {
-		name   string
-		args   args
-		verify func(*testing.T, *atesting.TestCase)
-	}{{
-		name: "normal",
-		args: args{
-			configFile: "a/b/c.yaml",
-			testcase: &atesting.TestCase{
-				Prepare: atesting.Prepare{
-					Kubernetes: []string{"deploy.yaml"},
-				},
-			},
-		},
-		verify: func(t *testing.T, testCase *atesting.TestCase) {
-			assert.Equal(t, "a/b/deploy.yaml", testCase.Prepare.Kubernetes[0])
-		},
-	}}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			setRelativeDir(tt.args.configFile, tt.args.testcase)
-			tt.verify(t, tt.args.testcase)
-		})
-	}
-}
-
 func TestCreateRunCommand(t *testing.T) {
 	cmd := createRunCommand()
 	assert.Equal(t, "run", cmd.Use)

cmd/run.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"fmt"
 	"os"
-	"path"
 	"path/filepath"
 	"strings"
 	"sync"
@@ -216,7 +215,6 @@ func (o *runOption) runSuite(suite string, dataContext map[string]interface{}, c
 		case <-stopSingal:
 			return
 		default:
-			setRelativeDir(suite, &testCase)
 			o.limiter.Accept()
 
 			ctxWithTimeout, _ := context.WithTimeout(ctx, o.requestTimeout)
@@ -238,11 +236,3 @@ func (o *runOption) runSuite(suite string, dataContext map[string]interface{}, c
 func getDefaultContext() map[string]interface{} {
 	return map[string]interface{}{}
 }
-
-func setRelativeDir(configFile string, testcase *testing.TestCase) {
-	dir := filepath.Dir(configFile)
-
-	for i := range testcase.Prepare.Kubernetes {
-		testcase.Prepare.Kubernetes[i] = path.Join(dir, testcase.Prepare.Kubernetes[i])
-	}
-}

pkg/runner/simple.go

@@ -180,15 +180,14 @@ func (r *simpleTestCaseRunner) RunTestCase(testcase *testing.TestCase, dataConte
 		r.testReporter.PutRecord(rr)
 	}(record)
 
-	if err = r.doPrepare(testcase); err != nil {
-		err = fmt.Errorf("failed to prepare, error: %v", err)
-		return
-	}
-
 	defer func() {
 		if testcase.Clean.CleanPrepare {
 			err = r.doCleanPrepare(testcase)
 		}
+
+		if err == nil {
+			err = runJob(testcase.After)
+		}
 	}()
 
 	client := http.Client{
@@ -216,6 +215,10 @@ func (r *simpleTestCaseRunner) RunTestCase(testcase *testing.TestCase, dataConte
 		request.Header.Add(key, val)
 	}
 
+	if err = runJob(testcase.Before); err != nil {
+		return
+	}
+
 	r.log.Info("start to send request to %s\n", testcase.Request.API)
 
 	// TODO only do this for unit testing, should remove it once we have a better way
@@ -286,8 +289,8 @@ func (r *simpleTestCaseRunner) WithExecer(execer fakeruntime.Execer) TestCaseRun
 }
 
 func (r *simpleTestCaseRunner) doPrepare(testcase *testing.TestCase) (err error) {
-	for i := range testcase.Prepare.Kubernetes {
-		item := testcase.Prepare.Kubernetes[i]
+	for i := range testcase.Before.Items {
+		item := testcase.Before.Items[i]
 
 		if err = r.execer.RunCommand("kubectl", "apply", "-f", item); err != nil {
 			return
@@ -297,9 +300,9 @@ func (r *simpleTestCaseRunner) doPrepare(testcase *testing.TestCase) (err error)
 }
 
 func (r *simpleTestCaseRunner) doCleanPrepare(testcase *testing.TestCase) (err error) {
-	count := len(testcase.Prepare.Kubernetes)
+	count := len(testcase.Before.Items)
 	for i := count - 1; i >= 0; i-- {
-		item := testcase.Prepare.Kubernetes[i]
+		item := testcase.Before.Items[i]
 
 		if err = r.execer.RunCommand("kubectl", "delete", "-f", item); err != nil {
 			return
@@ -413,3 +416,25 @@ func verifyResponseBodyData(caseName string, expect testing.Response, responseBo
 	}
 	return
 }
+
+func runJob(job testing.Job) (err error) {
+	var program *vm.Program
+	env := struct{}{}
+
+	for _, item := range job.Items {
+		if program, err = expr.Compile(item, expr.Env(env),
+			expr.Function("sleep", func(a ...interface{}) (interface{}, error) {
+				time.Sleep(time.Duration(a[0].(int)) * time.Second)
+				return nil, nil
+			})); err != nil {
+			fmt.Printf("failed to compile: %s, %v\n", item, err)
+			return
+		}
+
+		if _, err = expr.Run(program, env); err != nil {
+			fmt.Printf("failed to Run: %s, %v\n", item, err)
+			return
+		}
+	}
+	return
+}

pkg/runner/simple_test.go

@@ -43,8 +43,8 @@ func TestTestCase(t *testing.T) {
 	}{{
 		name: "failed during the prepare stage",
 		testCase: &atest.TestCase{
-			Prepare: atest.Prepare{
-				Kubernetes: []string{"demo.yaml"},
+			Before: atest.Job{
+				Items: []string{"demo.yaml"},
 			},
 		},
 		execer: fakeruntime.FakeExecer{ExpectError: errors.New("fake")},
@@ -69,8 +69,8 @@ func TestTestCase(t *testing.T) {
 					`data.name == "linuxsuren"`,
 				},
 			},
-			Prepare: atest.Prepare{
-				Kubernetes: []string{"demo.yaml"},
+			Before: atest.Job{
+				Items: []string{"sleep(1)"},
 			},
 			Clean: atest.Clean{
 				CleanPrepare: true,
@@ -411,6 +411,26 @@ func TestJSONSchemaValidation(t *testing.T) {
 	}
 }
 
+func TestRunJob(t *testing.T) {
+	tests := []struct {
+		name   string
+		job    atest.Job
+		hasErr bool
+	}{{
+		name: "sleep 1s",
+		job: atest.Job{
+			Items: []string{"sleep(1)"},
+		},
+		hasErr: false,
+	}}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := runJob(tt.job)
+			assert.Equal(t, tt.hasErr, err != nil, err)
+		})
+	}
+}
+
 const defaultSchemaForTest = `{"properties": {
 	"name": {"type": "string"},
 	"age": {"type": "integer"}

pkg/testing/case.go

@@ -11,7 +11,8 @@ type TestSuite struct {
 type TestCase struct {
 	Name    string `yaml:"name" json:"name"`
 	Group   string
-	Prepare Prepare  `yaml:"prepare" json:"-"`
+	Before  Job      `yaml:"before" json:"before"`
+	After   Job      `yaml:"after" json:"after"`
 	Request Request  `yaml:"request" json:"request"`
 	Expect  Response `yaml:"expect" json:"expect"`
 	Clean   Clean    `yaml:"clean" json:"-"`
@@ -31,9 +32,9 @@ func (c *TestCase) InScope(items []string) bool {
 	return false
 }
 
-// Prepare does the prepare work
-type Prepare struct {
-	Kubernetes []string `yaml:"kubernetes"`
+// Job contains a list of jobs
+type Job struct {
+	Items []string `yaml:"items"`
 }
 
 // Request represents a HTTP request

pkg/testing/parser_test.go

@@ -28,6 +28,12 @@ func TestParse(t *testing.T) {
 }
 `,
 			},
+			Before: Job{
+				Items: []string{"sleep(1)"},
+			},
+			After: Job{
+				Items: []string{"sleep(1)"},
+			},
 		}, suite.Items[0])
 	}
 

sample/api-testing-schema.json

@@ -37,6 +37,12 @@
                 },
                 "expect": {
                     "$ref": "#/definitions/Expect"
+                },
+                "before": {
+                    "$ref": "#/definitions/Job"
+                },
+                "after": {
+                    "$ref": "#/definitions/Job"
                 }
             },
             "required": [
@@ -121,6 +127,22 @@
                 "api"
             ],
             "title": "Request"
+        },
+        "Job": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "items": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                }
+            },
+            "required": [
+                "items"
+            ],
+            "title": "Job"
         }
     }
 }

sample/testsuite-gitee.yaml

@@ -4,6 +4,9 @@ name: Gitee
 api: https://gitee.com/api/v5
 items:
 - name: stargazers
+  before:
+    items:
+    - sleep(1)
   request:
     api: /repos/linuxsuren/api-testing/stargazers
   expect:

sample/testsuite-gitlab.yaml

@@ -12,6 +12,12 @@ items:
       {
         "type": "array"
       }
+  before:
+    items:
+      - "sleep(1)"
+  after:
+    items:
+      - "sleep(1)"
 - name: project
   request:
     api: https://gitlab.com/api/v4/projects/{{int64 (index .projects 0).id}}