refactor: change number to http status
change 200 to http.StatusOk
change 400 to http.StatusBadRequest
change 404 to http.StatusNotFound
change 500 to http.StatusInternalServerError
Nddtfjiang <zhicheng.jiang@merico.dev>
diff --git a/plugins/helper/api_async_client.go b/plugins/helper/api_async_client.go
index f8806ea..8b8777b 100644
--- a/plugins/helper/api_async_client.go
+++ b/plugins/helper/api_async_client.go
@@ -16,7 +16,7 @@
type ApiAsyncCallback func(*http.Response, error) error
-var HttpMinStatusRetryCode = 400
+var HttpMinStatusRetryCode = http.StatusBadRequest
// ApiAsyncClient is built on top of ApiClient, to provide a asynchronous semantic
// You may submit multiple requests at once by calling `GetAsync`, and those requests
diff --git a/plugins/helper/api_async_client_test.go b/plugins/helper/api_async_client_test.go
deleted file mode 100644
index 5812708..0000000
--- a/plugins/helper/api_async_client_test.go
+++ /dev/null
@@ -1,336 +0,0 @@
-package helper
-
-import (
- "context"
- "fmt"
- "io"
- "io/ioutil"
- "net/http"
- "net/url"
- "os"
- "reflect"
- "sync/atomic"
- "testing"
- "time"
-
- "github.com/agiledragon/gomonkey/v2"
- "github.com/merico-dev/lake/plugins/core"
- "github.com/sirupsen/logrus"
- "github.com/spf13/viper"
- "github.com/stretchr/testify/assert"
- "gorm.io/gorm"
-)
-
-// TestReadder for test io data
-type TestReader struct {
- Err error
-}
-
-func (r *TestReader) Read(p []byte) (n int, err error) {
- return 0, r.Err
-}
-
-func (r *TestReader) Close() error {
- return nil
-}
-
-// it is better to move some where more public.
-var ErrUnitTest error = fmt.Errorf("ErrorForTest[%d]", time.Now().UnixNano())
-
-func callback(_ *http.Response, err error) error {
- if err == nil {
- return nil
- }
- return ErrUnitTest
-}
-
-func GetConfigForTest(basepath string) *viper.Viper {
- // create the object and load the .env file
- v := viper.New()
- envfile := ".env"
- envbasefile := basepath + ".env.example"
- bytesRead, err := ioutil.ReadFile(envbasefile)
- if err != nil {
- logrus.Warn("Failed to read ["+envbasefile+"] file:", err)
- }
- err = ioutil.WriteFile(envfile, bytesRead, 0644)
-
- if err != nil {
- logrus.Warn("Failed to write config file ["+envfile+"] file:", err)
- }
-
- v.SetConfigFile(envfile)
- err = v.ReadInConfig()
- if err != nil {
- path, _ := os.Getwd()
- logrus.Warn("Now in the path [" + path + "]")
- logrus.Warn("Failed to read ["+envfile+"] file:", err)
- }
- v.AutomaticEnv()
- // This line is essential for reading and writing
- v.WatchConfig()
- return v
-}
-
-// Create an AsyncApiClient object for test
-func CreateTestAsyncApiClient(t *testing.T) (*ApiAsyncClient, error) {
- // create rate limit calculator
- rateLimiter := &ApiRateLimitCalculator{
- UserRateLimitPerHour: 36000, // ten times each seconed
- }
-
- // set the function of create new default taskcontext for the AsyncApiClient
- gm := gomonkey.ApplyFunc(NewDefaultTaskContext, func(
- cfg *viper.Viper,
- _ core.Logger,
- db *gorm.DB,
- _ context.Context,
- name string,
- subtasks map[string]bool,
- progress chan core.RunningProgress,
- ) core.TaskContext {
- return &DefaultTaskContext{
- &defaultExecContext{
- cfg: cfg,
- logger: &DefaultLogger{},
- db: db,
- ctx: context.Background(),
- name: "Test",
- data: nil,
- progress: progress,
- },
- subtasks,
- make(map[string]*DefaultSubTaskContext),
- }
- })
- defer gm.Reset()
- taskCtx := NewDefaultTaskContext(GetConfigForTest("../../"), nil, nil, nil, "", nil, nil)
-
- // create ApiClient
- apiClient := &ApiClient{}
- apiClient.Setup("", nil, 3*time.Second)
- apiClient.SetContext(taskCtx.GetContext())
-
- return CreateAsyncApiClient(taskCtx, apiClient, rateLimiter)
-}
-
-// go test -gcflags=all=-l -run ^TestWaitAsync_EmptyWork
-func TestWaitAsync_EmptyWork(t *testing.T) {
- asyncApiClient, _ := CreateTestAsyncApiClient(t)
-
- err := asyncApiClient.WaitAsync()
- assert.Equal(t, err, nil)
-}
-
-// go test -gcflags=all=-l -run ^TestWaitAsync_WithWork
-func TestWaitAsync_WithWork(t *testing.T) {
- asyncApiClient, _ := CreateTestAsyncApiClient(t)
-
- gm_info := gomonkey.ApplyMethod(reflect.TypeOf(&DefaultLogger{}), "Info", func(_ *DefaultLogger, _ string, _ ...interface{}) {
- })
- defer gm_info.Reset()
-
- gm_do := gomonkey.ApplyMethod(reflect.TypeOf(&ApiClient{}), "Do", func(
- apiClient *ApiClient,
- method string,
- path string,
- query url.Values,
- body interface{},
- headers http.Header,
- ) (*http.Response, error) {
- return &http.Response{
- Body: &TestReader{Err: io.EOF},
- StatusCode: 200,
- }, nil
- })
- defer gm_do.Reset()
-
- // check if the callback1 has been finished
- waitSuc := false
- callback1 := func(_ *http.Response, err error) error {
- // wait 0.5 second for wait
- time.Sleep(500 * time.Millisecond)
- waitSuc = true
- return nil
- }
-
- // begin to test
- err := asyncApiClient.DoAsync("", "", nil, nil, nil, callback1, 0)
- assert.Equal(t, err, nil)
-
- err = asyncApiClient.WaitAsync()
- assert.Equal(t, err, nil)
- assert.Equal(t, waitSuc, true)
-}
-
-// go test -gcflags=all=-l -run ^TestWaitAsync_MutiWork
-func TestWaitAsync_MutiWork(t *testing.T) {
- asyncApiClient, _ := CreateTestAsyncApiClient(t)
-
- gm_info := gomonkey.ApplyMethod(reflect.TypeOf(&DefaultLogger{}), "Info", func(_ *DefaultLogger, _ string, _ ...interface{}) {
- })
- defer gm_info.Reset()
-
- gm_do := gomonkey.ApplyMethod(reflect.TypeOf(&ApiClient{}), "Do", func(
- apiClient *ApiClient,
- method string,
- path string,
- query url.Values,
- body interface{},
- headers http.Header,
- ) (*http.Response, error) {
- return &http.Response{
- Body: &TestReader{Err: io.EOF},
- StatusCode: 200,
- }, nil
- })
- defer gm_do.Reset()
-
- // check if the callback2 has been finished
- finishedCount := int64(0)
- callback2 := func(_ *http.Response, err error) error {
- // wait 0.5 second for wait
- time.Sleep(500 * time.Millisecond)
- atomic.AddInt64(&finishedCount, 1)
- return nil
- }
-
- testCount := int64(5)
-
- // begin to test
- for i := int64(0); i < testCount; i++ {
- err := asyncApiClient.DoAsync("", "", nil, nil, nil, callback2, 0)
- assert.Equal(t, err, nil)
- }
-
- err := asyncApiClient.WaitAsync()
- assert.Equal(t, err, nil)
- assert.Equal(t, finishedCount, testCount)
-}
-
-// go test -gcflags=all=-l -run ^TestDoAsync_OnceSuceess
-func TestDoAsync_OnceSuceess(t *testing.T) {
- asyncApiClient, _ := CreateTestAsyncApiClient(t)
- gm_info := gomonkey.ApplyMethod(reflect.TypeOf(&DefaultLogger{}), "Info", func(_ *DefaultLogger, _ string, _ ...interface{}) {
- })
- defer gm_info.Reset()
-
- gm_do := gomonkey.ApplyMethod(reflect.TypeOf(&ApiClient{}), "Do", func(
- apiClient *ApiClient,
- method string,
- path string,
- query url.Values,
- body interface{},
- headers http.Header,
- ) (*http.Response, error) {
- return &http.Response{
- Body: &TestReader{Err: io.EOF},
- StatusCode: 200,
- }, nil
- })
- defer gm_do.Reset()
-
- // ready to test
- err := asyncApiClient.DoAsync("", "", nil, nil, nil, callback, 0)
- assert.Equal(t, err, nil)
-
- err = asyncApiClient.WaitAsync()
- assert.Equal(t, err, nil)
-}
-
-// go test -gcflags=all=-l -run ^TestDoAsync_TryAndFail
-func TestDoAsync_TryAndFail(t *testing.T) {
- asyncApiClient, _ := CreateTestAsyncApiClient(t)
- gm_info := gomonkey.ApplyMethod(reflect.TypeOf(&DefaultLogger{}), "Info", func(_ *DefaultLogger, _ string, _ ...interface{}) {
- })
- defer gm_info.Reset()
-
- gm_do := gomonkey.ApplyMethod(reflect.TypeOf(&ApiClient{}), "Do", func(
- apiClient *ApiClient,
- method string,
- path string,
- query url.Values,
- body interface{},
- headers http.Header,
- ) (*http.Response, error) {
- return &http.Response{
- Body: &TestReader{Err: ErrUnitTest},
- StatusCode: 500,
- }, nil
- })
- defer gm_do.Reset()
-
- // ready to test
- err := asyncApiClient.DoAsync("", "", nil, nil, nil, callback, 0)
- assert.Equal(t, err, nil)
-
- err = asyncApiClient.WaitAsync()
- // there must have err and the err must be ErrUnitTest
- if assert.NotNil(t, err) {
- assert.Contains(t, err.Error(), ErrUnitTest.Error())
- }
-}
-
-// go test -gcflags=all=-l -run ^TestDoAsync_TryAndSuceess
-func TestDoAsync_TryAndSuceess(t *testing.T) {
- asyncApiClient, _ := CreateTestAsyncApiClient(t)
- gm_info := gomonkey.ApplyMethod(reflect.TypeOf(&DefaultLogger{}), "Info", func(_ *DefaultLogger, _ string, _ ...interface{}) {
- })
- defer gm_info.Reset()
-
- // counting the retry times
- times := 0
- gm_do := gomonkey.ApplyMethod(reflect.TypeOf(&ApiClient{}), "Do", func(
- apiClient *ApiClient,
- method string,
- path string,
- query url.Values,
- body interface{},
- headers http.Header,
- ) (*http.Response, error) {
- times++
- switch times {
- case 1:
- return &http.Response{
- Body: &TestReader{Err: ErrUnitTest},
- StatusCode: 500,
- }, nil
- case 2:
- return &http.Response{
- Body: &TestReader{Err: io.EOF},
- StatusCode: 500,
- }, nil
- case 3:
- return &http.Response{
- Body: &TestReader{Err: io.EOF},
- StatusCode: 400,
- }, nil
- case 4:
- return &http.Response{
- Body: &TestReader{Err: io.EOF},
- StatusCode: 300,
- }, nil
- case 5:
- return &http.Response{
- Body: &TestReader{Err: io.EOF},
- StatusCode: 200,
- }, nil
- default:
- assert.Empty(t, TestNoRunHere)
- return &http.Response{
- Body: &TestReader{Err: io.EOF},
- StatusCode: 200,
- }, TestError
- }
- })
- defer gm_do.Reset()
- asyncApiClient.SetMaxRetry(5)
-
- // ready to test
- err := asyncApiClient.DoAsync("", "", nil, nil, nil, callback, 0)
- assert.Equal(t, err, nil)
-
- err = asyncApiClient.WaitAsync()
- assert.Equal(t, err, nil)
- assert.Equal(t, times, 4)
-}
