feat: support to calculate the API coverage

LinuxSuRen · LinuxSuRen · commit 08f2907c3c0c · 2023-06-13T22:44:56.000+08:00
diff --git a/cmd/function.go b/cmd/function.go
@@ -1,7 +1,6 @@
 package cmd
 
 import (
-	"fmt"
 	"go/ast"
 	"go/doc"
 	"go/parser"
@@ -26,7 +25,7 @@ func createFunctionCmd() (c *cobra.Command) {
 					cmd.Println(reflect.TypeOf(fn))
 					desc := FuncDescription(fn)
 					if desc != "" {
-						fmt.Println(desc)
+						cmd.Println(desc)
 					}
 				} else {
 					cmd.Println("No such function")
diff --git a/cmd/run.go b/cmd/run.go
@@ -11,6 +11,7 @@ import (
 	"sync"
 	"time"
 
+	"github.com/linuxsuren/api-testing/pkg/apispec"
 	"github.com/linuxsuren/api-testing/pkg/limit"
 	"github.com/linuxsuren/api-testing/pkg/render"
 	"github.com/linuxsuren/api-testing/pkg/runner"
@@ -35,6 +36,7 @@ type runOption struct {
 	reportWriter       runner.ReportResultWriter
 	report             string
 	reportIgnore       bool
+	swaggerURL         string
 	level              string
 	caseItems          []string
 }
@@ -77,6 +79,7 @@ See also https://github.com/LinuxSuRen/api-testing/tree/master/sample`,
 	flags.StringVarP(&opt.report, "report", "", "", "The type of target report. Supported: markdown, md, html, discard, std")
 	flags.StringVarP(&opt.reportFile, "report-file", "", "", "The file path of the report")
 	flags.BoolVarP(&opt.reportIgnore, "report-ignore", "", false, "Indicate if ignore the report output")
+	flags.StringVarP(&opt.swaggerURL, "swagger-url", "", "", "The URL of swagger")
 	flags.Int64VarP(&opt.thread, "thread", "", 1, "Threads of the execution")
 	flags.Int32VarP(&opt.qps, "qps", "", 5, "QPS")
 	flags.Int32VarP(&opt.burst, "burst", "", 5, "burst")
@@ -108,6 +111,15 @@ func (o *runOption) preRunE(cmd *cobra.Command, args []string) (err error) {
 		err = fmt.Errorf("not supported report type: '%s'", o.report)
 	}
 
+	if err == nil {
+		var swaggerAPI apispec.APIConverage
+		if o.swaggerURL != "" {
+			if swaggerAPI, err = apispec.ParseURLToSwagger(o.swaggerURL); err == nil {
+				o.reportWriter.WithAPIConverage(swaggerAPI)
+			}
+		}
+	}
+
 	o.caseItems = args
 	return
 }
diff --git a/cmd/run_test.go b/cmd/run_test.go
@@ -115,6 +115,14 @@ func TestRunCommand(t *testing.T) {
 		prepare: fooPrepare,
 		args:    []string{"-p", simpleSuite, "--report", "md", "--report-file", tmpFile.Name()},
 		hasErr:  false,
+	}, {
+		name: "report with swagger URL",
+		prepare: func() {
+			fooPrepare()
+			fooPrepare()
+		},
+		args:   []string{"-p", simpleSuite, "--swagger-url", urlFoo + "/bar"},
+		hasErr: false,
 	}, {
 		name:    "report file with error",
 		prepare: fooPrepare,
@@ -124,9 +132,10 @@ func TestRunCommand(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			defer gock.Clean()
+			buf := new(bytes.Buffer)
 			util.MakeSureNotNil(tt.prepare)()
 			root := &cobra.Command{Use: "root"}
-			root.SetOut(&bytes.Buffer{})
+			root.SetOut(buf)
 			root.AddCommand(createRunCommand())
 
 			root.SetArgs(append([]string{"run"}, tt.args...))
@@ -184,6 +193,15 @@ func TestPreRunE(t *testing.T) {
 			assert.Nil(t, err)
 			assert.NotNil(t, ro.reportWriter)
 		},
+	}, {
+		name: "html report",
+		opt: &runOption{
+			report: "html",
+		},
+		verify: func(t *testing.T, ro *runOption, err error) {
+			assert.Nil(t, err)
+			assert.NotNil(t, ro.reportWriter)
+		},
 	}, {
 		name: "empty report",
 		opt: &runOption{
diff --git a/pkg/apispec/swagger.go b/pkg/apispec/swagger.go
@@ -0,0 +1,98 @@
+package apispec
+
+import (
+	"encoding/json"
+	"io"
+	"net/http"
+	"regexp"
+	"strings"
+)
+
+type Swagger struct {
+	Swagger string                           `json:"swagger"`
+	Paths   map[string]map[string]SwaggerAPI `json:"paths"`
+	Info    SwaggerInfo                      `json:"info"`
+}
+
+type SwaggerAPI struct {
+	OperationId string `json:"operationId"`
+	Summary     string `json:"summary"`
+}
+
+type SwaggerInfo struct {
+	Description string `json:"description"`
+	Title       string `json:"title"`
+	Version     string `json:"version"`
+}
+
+type APIConverage interface {
+	HaveAPI(path, method string) (exist bool)
+	APICount() (count int)
+}
+
+// HaveAPI check if the swagger has the API.
+// If the path is /api/v1/names/linuxsuren, then will match /api/v1/names/{name}
+func (s *Swagger) HaveAPI(path, method string) (exist bool) {
+	method = strings.ToLower(method)
+	for item := range s.Paths {
+		if matchAPI(path, item) {
+			for m := range s.Paths[item] {
+				if strings.ToLower(m) == method {
+					exist = true
+					return
+				}
+			}
+		}
+	}
+	return
+}
+
+func matchAPI(particularAPI, swaggerAPI string) (matched bool) {
+	result := swaggerAPIConvert(swaggerAPI)
+	reg, err := regexp.Compile(result)
+	if err == nil {
+		matched = reg.MatchString(particularAPI)
+	}
+	return
+}
+
+func swaggerAPIConvert(text string) (result string) {
+	result = text
+	reg, err := regexp.Compile("{.*}")
+	if err == nil {
+		result = reg.ReplaceAllString(text, ".*")
+	}
+	return
+}
+
+// APICount return the count of APIs
+func (s *Swagger) APICount() (count int) {
+	for path := range s.Paths {
+		for range s.Paths[path] {
+			count++
+		}
+	}
+	return
+}
+
+func ParseToSwagger(data []byte) (swagger *Swagger, err error) {
+	swagger = &Swagger{}
+	err = json.Unmarshal(data, swagger)
+	return
+}
+
+func ParseURLToSwagger(swaggerURL string) (swagger *Swagger, err error) {
+	var resp *http.Response
+	if resp, err = http.Get(swaggerURL); err == nil && resp != nil && resp.StatusCode == http.StatusOK {
+		swagger, err = ParseStreamToSwagger(resp.Body)
+	}
+	return
+}
+
+func ParseStreamToSwagger(stream io.Reader) (swagger *Swagger, err error) {
+	var data []byte
+	if data, err = io.ReadAll(stream); err == nil {
+		swagger, err = ParseToSwagger(data)
+	}
+	return
+}
diff --git a/pkg/apispec/swagger_test.go b/pkg/apispec/swagger_test.go
@@ -0,0 +1,111 @@
+package apispec_test
+
+import (
+	"net/http"
+	"testing"
+
+	_ "embed"
+
+	"github.com/h2non/gock"
+	"github.com/linuxsuren/api-testing/pkg/apispec"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestParseURLToSwagger(t *testing.T) {
+	tests := []struct {
+		name       string
+		swaggerURL string
+		verify     func(t *testing.T, swagger *apispec.Swagger, err error)
+	}{{
+		name:       "normal",
+		swaggerURL: "http://foo",
+		verify: func(t *testing.T, swagger *apispec.Swagger, err error) {
+			assert.NoError(t, err)
+			assert.Equal(t, "2.0", swagger.Swagger)
+			assert.Equal(t, apispec.SwaggerInfo{
+				Description: "sample",
+				Title:       "sample",
+				Version:     "1.0.0",
+			}, swagger.Info)
+		},
+	}}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gock.New(tt.swaggerURL).Get("/").Reply(200).BodyString(testdataSwaggerJSON)
+			defer gock.Off()
+
+			s, err := apispec.ParseURLToSwagger(tt.swaggerURL)
+			tt.verify(t, s, err)
+		})
+	}
+}
+
+func TestHaveAPI(t *testing.T) {
+	tests := []struct {
+		name         string
+		swaggerURL   string
+		path, method string
+		expectExist  bool
+	}{{
+		name:        "normal, exist",
+		swaggerURL:  "http://foo",
+		path:        "/api/v1/users",
+		method:      http.MethodGet,
+		expectExist: true,
+	}, {
+		name:        "create user, exist",
+		swaggerURL:  "http://foo",
+		path:        "/api/v1/users",
+		method:      http.MethodPost,
+		expectExist: true,
+	}, {
+		name:        "get a user, exist",
+		swaggerURL:  "http://foo",
+		path:        "/api/v1/users/linuxsuren",
+		method:      http.MethodGet,
+		expectExist: true,
+	}, {
+		name:        "normal, not exist",
+		swaggerURL:  "http://foo",
+		path:        "/api/v1/users",
+		method:      http.MethodDelete,
+		expectExist: false,
+	}}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gock.New(tt.swaggerURL).Get("/").Reply(200).BodyString(testdataSwaggerJSON)
+			defer gock.Off()
+
+			swagger, err := apispec.ParseURLToSwagger(tt.swaggerURL)
+			assert.NoError(t, err)
+			exist := swagger.HaveAPI(tt.path, tt.method)
+			assert.Equal(t, tt.expectExist, exist)
+		})
+	}
+}
+
+func TestAPICount(t *testing.T) {
+	tests := []struct {
+		name        string
+		swaggerURL  string
+		expectCount int
+	}{{
+		name:        "normal",
+		swaggerURL:  "http://foo",
+		expectCount: 5,
+	}}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gock.New(tt.swaggerURL).Get("/").Reply(200).BodyString(testdataSwaggerJSON)
+			defer gock.Off()
+
+			swagger, err := apispec.ParseURLToSwagger(tt.swaggerURL)
+			assert.NoError(t, err)
+			count := swagger.APICount()
+			assert.Equal(t, tt.expectCount, count)
+		})
+	}
+}
+
+//go:embed testdata/swagger.json
+var testdataSwaggerJSON string
diff --git a/pkg/apispec/testdata/swagger.json b/pkg/apispec/testdata/swagger.json
@@ -0,0 +1,34 @@
+{
+    "swagger": "2.0",
+    "info": {
+        "description": "sample",
+        "title": "sample",
+        "version": "1.0.0"
+    },
+    "paths": {
+        "/api/v1/users": {
+            "get": {
+                "summary": "summary",
+                "operationId": "getUsers"
+            },
+            "post": {
+                "summary": "summary",
+                "operationId": "createUser"
+            }
+        },
+        "/api/v1/users/{user}": {
+            "get": {
+                "summary": "summary",
+                "operationId": "getUser"
+            },
+            "delete": {
+                "summary": "summary",
+                "operationId": "deleteUser"
+            },
+            "put": {
+                "summary": "summary",
+                "operationId": "updateUser"
+            }
+        }
+    }
+}
diff --git a/pkg/runner/simple.go b/pkg/runner/simple.go
@@ -14,6 +14,7 @@ import (
 	"github.com/andreyvit/diff"
 	"github.com/antonmedv/expr"
 	"github.com/antonmedv/expr/vm"
+	"github.com/linuxsuren/api-testing/pkg/apispec"
 	"github.com/linuxsuren/api-testing/pkg/runner/kubernetes"
 	"github.com/linuxsuren/api-testing/pkg/testing"
 	fakeruntime "github.com/linuxsuren/go-fake-runtime"
@@ -153,6 +154,7 @@ func (r ReportResultSlice) Swap(i, j int) {
 // ReportResultWriter is the interface of the report writer
 type ReportResultWriter interface {
 	Output([]ReportResult) error
+	WithAPIConverage(apiConverage apispec.APIConverage) ReportResultWriter
 }
 
 // TestReporter is the interface of the report
diff --git a/pkg/runner/writer_html.go b/pkg/runner/writer_html.go
@@ -4,11 +4,13 @@ import (
 	_ "embed"
 	"io"
 
+	"github.com/linuxsuren/api-testing/pkg/apispec"
 	"github.com/linuxsuren/api-testing/pkg/render"
 )
 
 type htmlResultWriter struct {
-	writer io.Writer
+	writer       io.Writer
+	apiConverage apispec.APIConverage
 }
 
 // NewHTMLResultWriter creates a new htmlResultWriter
@@ -21,5 +23,11 @@ func (w *htmlResultWriter) Output(result []ReportResult) (err error) {
 	return render.RenderThenPrint("html-report", htmlReport, result, w.writer)
 }
 
+// WithAPIConverage sets the api coverage
+func (w *htmlResultWriter) WithAPIConverage(apiConverage apispec.APIConverage) ReportResultWriter {
+	w.apiConverage = apiConverage
+	return w
+}
+
 //go:embed data/html.html
 var htmlReport string
diff --git a/pkg/runner/writer_html_test.go b/pkg/runner/writer_html_test.go
@@ -32,6 +32,7 @@ func TestHTMLResultWriter(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			w := runner.NewHTMLResultWriter(tt.buf)
+			w.WithAPIConverage(nil)
 			err := w.Output(tt.results)
 			assert.NoError(t, err)
 			assert.Equal(t, tt.expect, tt.buf.String())
diff --git a/pkg/runner/writer_markdown.go b/pkg/runner/writer_markdown.go
diff --git a/pkg/runner/writer_markdown_test.go b/pkg/runner/writer_markdown_test.go
diff --git a/pkg/runner/writer_std.go b/pkg/runner/writer_std.go
diff --git a/pkg/runner/writer_std_test.go b/pkg/runner/writer_std_test.go
