You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@devlake.apache.org by wa...@apache.org on 2022/06/06 15:49:51 UTC

[incubator-devlake] 03/04: unit test for connection

This is an automated email from the ASF dual-hosted git repository.

warren pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/incubator-devlake.git

commit 7b485ed07d871150946de3390fd7e3e6fb9e757a
Author: Yingchu Chen <yi...@merico.dev>
AuthorDate: Wed Jun 1 19:07:30 2022 +0800

    unit test for connection
    
    Signed-off-by: Yingchu Chen <yi...@merico.dev>
---
 plugins/helper/connection.go      |  49 +++++------
 plugins/helper/connection_test.go | 178 ++++++++++++++++++++++++++++++++++++++
 plugins/jira/tasks/api_client.go  |   9 +-
 3 files changed, 205 insertions(+), 31 deletions(-)

diff --git a/plugins/helper/connection.go b/plugins/helper/connection.go
index 85163068..17933a5c 100644
--- a/plugins/helper/connection.go
+++ b/plugins/helper/connection.go
@@ -21,7 +21,7 @@ type BaseConnection struct {
 
 type BasicAuth struct {
 	Username string `mapstructure:"username" validate:"required" json:"username"`
-	Password string `mapstructure:"password" validate:"required" json:"password" encrypt:"yes"`
+	Password string `mapstructure:"password" validate:"required" json:"password" encryptField:"yes"`
 }
 
 func (ba BasicAuth) GetEncodedToken() string {
@@ -29,7 +29,7 @@ func (ba BasicAuth) GetEncodedToken() string {
 }
 
 type AccessToken struct {
-	Token string `mapstructure:"token" validate:"required" json:"token" encrypt:"yes"`
+	Token string `mapstructure:"token" validate:"required" json:"token" encryptField:"yes"`
 }
 
 type RestConnection struct {
@@ -65,11 +65,14 @@ func saveToDb(connection interface{}, db *gorm.DB) error {
 	if dataVal.Kind() != reflect.Ptr {
 		panic("entityPtr is not a pointer")
 	}
-
+	encKey, err := getEncKey()
+	if err != nil {
+		return err
+	}
 	dataType := reflect.Indirect(dataVal).Type()
-	fieldName := getEncryptField(dataType, "encrypt")
+	fieldName := firstFieldNameWithTag(dataType, "encryptField")
 	plainPwd := ""
-	err := doEncrypt(dataVal, fieldName)
+	err = encryptField(dataVal, fieldName, encKey)
 	if err != nil {
 		return err
 	}
@@ -78,7 +81,7 @@ func saveToDb(connection interface{}, db *gorm.DB) error {
 		return err
 	}
 
-	err = doDecrypt(dataVal, fieldName)
+	err = decryptField(dataVal, fieldName, encKey)
 	if err != nil {
 		return err
 	}
@@ -107,7 +110,7 @@ func mergeFieldsToConnection(specificConnection interface{}, connections ...map[
 }
 
 func getEncKey() (string, error) {
-	// encrypt
+	// encryptField
 	v := config.GetConfig()
 	encKey := v.GetString(core.EncodeKeyEnvStr)
 	if encKey == "" {
@@ -142,8 +145,8 @@ func FindConnectionByInput(input *core.ApiResourceInput, connection interface{},
 
 	dataType := reflect.Indirect(dataVal).Type()
 
-	fieldName := getEncryptField(dataType, "encrypt")
-	return doDecrypt(dataVal, fieldName)
+	fieldName := firstFieldNameWithTag(dataType, "encryptField")
+	return decryptField(dataVal, fieldName, "")
 
 }
 
@@ -156,12 +159,12 @@ func GetConnectionIdByInputParam(input *core.ApiResourceInput) (uint64, error) {
 	return strconv.ParseUint(connectionId, 10, 64)
 }
 
-func getEncryptField(t reflect.Type, tag string) string {
+func firstFieldNameWithTag(t reflect.Type, tag string) string {
 	fieldName := ""
 	for i := 0; i < t.NumField(); i++ {
 		field := t.Field(i)
 		if field.Type.Kind() == reflect.Struct {
-			fieldName = getEncryptField(field.Type, tag)
+			fieldName = firstFieldNameWithTag(field.Type, tag)
 		} else {
 			if field.Tag.Get(tag) == "yes" {
 				fieldName = field.Name
@@ -177,34 +180,30 @@ func DecryptConnection(connection interface{}, fieldName string) error {
 	if dataVal.Kind() != reflect.Ptr {
 		panic("connection is not a pointer")
 	}
+	encKey, err := getEncKey()
+	if err != nil {
+		return nil
+	}
 	if len(fieldName) == 0 {
 		dataType := reflect.Indirect(dataVal).Type()
-		fieldName = getEncryptField(dataType, "encrypt")
+		fieldName = firstFieldNameWithTag(dataType, "encryptField")
 	}
-	return doDecrypt(dataVal, fieldName)
+	return decryptField(dataVal, fieldName, encKey)
 }
 
-func doDecrypt(dataVal reflect.Value, fieldName string) error {
-	encryptCode, err := getEncKey()
-	if err != nil {
-		return err
-	}
+func decryptField(dataVal reflect.Value, fieldName string, encKey string) error {
 	if len(fieldName) > 0 {
-		decryptStr, _ := core.Decrypt(encryptCode, dataVal.Elem().FieldByName(fieldName).String())
+		decryptStr, _ := core.Decrypt(encKey, dataVal.Elem().FieldByName(fieldName).String())
 
 		dataVal.Elem().FieldByName(fieldName).Set(reflect.ValueOf(decryptStr))
 	}
 	return nil
 }
 
-func doEncrypt(dataVal reflect.Value, fieldName string) error {
-	encryptCode, err := getEncKey()
-	if err != nil {
-		return err
-	}
+func encryptField(dataVal reflect.Value, fieldName string, encKey string) error {
 	if len(fieldName) > 0 {
 		plainPwd := dataVal.Elem().FieldByName(fieldName).String()
-		encyptedStr, err := core.Encrypt(encryptCode, plainPwd)
+		encyptedStr, err := core.Encrypt(encKey, plainPwd)
 
 		if err != nil {
 			return err
diff --git a/plugins/helper/connection_test.go b/plugins/helper/connection_test.go
new file mode 100644
index 00000000..606730f3
--- /dev/null
+++ b/plugins/helper/connection_test.go
@@ -0,0 +1,178 @@
+/*
+Licensed to the Apache Software Foundation (ASF) under one or more
+contributor license agreements.  See the NOTICE file distributed with
+this work for additional information regarding copyright ownership.
+The ASF licenses this file to You under the Apache License, Version 2.0
+(the "License"); you may not use this file except in compliance with
+the License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package helper
+
+import (
+	"github.com/apache/incubator-devlake/config"
+	"github.com/apache/incubator-devlake/plugins/core"
+	"reflect"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+type TestConnection struct {
+	RestConnection             `mapstructure:",squash"`
+	BasicAuth                  `mapstructure:",squash"`
+	EpicKeyField               string `gorm:"type:varchar(50);" json:"epicKeyField"`
+	StoryPointField            string `gorm:"type:varchar(50);" json:"storyPointField"`
+	RemotelinkCommitShaPattern string `gorm:"type:varchar(255);comment='golang regexp, the first group will be recognized as commit sha, ref https://github.com/google/re2/wiki/Syntax'" json:"remotelinkCommitShaPattern"`
+}
+
+func TestMergeFieldsToConnection(t *testing.T) {
+	v := &TestConnection{
+		RestConnection: RestConnection{
+			BaseConnection: BaseConnection{
+				Name: "1",
+			},
+			Endpoint:  "2",
+			Proxy:     "3",
+			RateLimit: 0,
+		},
+		BasicAuth: BasicAuth{
+			Username: "4",
+			Password: "5",
+		},
+		EpicKeyField:               "6",
+		StoryPointField:            "7",
+		RemotelinkCommitShaPattern: "8",
+	}
+	data := make(map[string]interface{})
+	data["Endpoint"] = "2-2"
+	data["Username"] = "4-4"
+	data["Password"] = "5-5"
+
+	err := mergeFieldsToConnection(v, data)
+	if err != nil {
+		return
+	}
+
+	assert.Equal(t, "4-4", v.Username)
+	assert.Equal(t, "2-2", v.Endpoint)
+	assert.Equal(t, "5-5", v.Password)
+}
+
+func TestDecryptAndEncrypt(t *testing.T) {
+	v := &TestConnection{
+		RestConnection: RestConnection{
+			BaseConnection: BaseConnection{
+				Name: "1",
+			},
+			Endpoint:  "2",
+			Proxy:     "3",
+			RateLimit: 0,
+		},
+		BasicAuth: BasicAuth{
+			Username: "4",
+			Password: "5",
+		},
+		EpicKeyField:               "6",
+		StoryPointField:            "7",
+		RemotelinkCommitShaPattern: "8",
+	}
+	dataVal := reflect.ValueOf(v)
+	encKey := "test"
+	err := encryptField(dataVal, "Password", encKey)
+	if err != nil {
+		return
+	}
+	assert.NotEqual(t, "5", v.Password)
+	err = decryptField(dataVal, "Password", encKey)
+	if err != nil {
+		return
+	}
+
+	assert.Equal(t, "5", v.Password)
+
+}
+
+func TestDecryptConnection(t *testing.T) {
+	v := &TestConnection{
+		RestConnection: RestConnection{
+			BaseConnection: BaseConnection{
+				Name: "1",
+			},
+			Endpoint:  "2",
+			Proxy:     "3",
+			RateLimit: 0,
+		},
+		BasicAuth: BasicAuth{
+			Username: "4",
+			Password: "5",
+		},
+		EpicKeyField:               "6",
+		StoryPointField:            "7",
+		RemotelinkCommitShaPattern: "8",
+	}
+	encKey, err := getEncKey()
+	if err != nil {
+		return
+	}
+	dataVal := reflect.ValueOf(v)
+	err = encryptField(dataVal, "Password", encKey)
+	if err != nil {
+		return
+	}
+	encryptedPwd := v.Password
+	err = DecryptConnection(v, "Password")
+	if err != nil {
+		return
+	}
+	assert.NotEqual(t, encryptedPwd, v.Password)
+	assert.Equal(t, "5", v.Password)
+}
+
+func TestGetEncKey(t *testing.T) {
+	// encryptField
+	v := config.GetConfig()
+	encKey := v.GetString(core.EncodeKeyEnvStr)
+	str, err := getEncKey()
+	if err != nil {
+		return
+	}
+	if len(encKey) > 0 {
+		assert.Equal(t, encKey, str)
+	} else {
+		assert.NotEqual(t, 0, len(str))
+	}
+
+}
+
+func TestFirstFieldNameWithTag(t *testing.T) {
+	v := &TestConnection{
+		RestConnection: RestConnection{
+			BaseConnection: BaseConnection{
+				Name: "1",
+			},
+			Endpoint:  "2",
+			Proxy:     "3",
+			RateLimit: 0,
+		},
+		BasicAuth: BasicAuth{
+			Username: "4",
+			Password: "5",
+		},
+		EpicKeyField:               "6",
+		StoryPointField:            "7",
+		RemotelinkCommitShaPattern: "8",
+	}
+	dataVal := reflect.ValueOf(v)
+	dataType := reflect.Indirect(dataVal).Type()
+	fieldName := firstFieldNameWithTag(dataType, "encryptField")
+	assert.Equal(t, "Password", fieldName)
+}
diff --git a/plugins/jira/tasks/api_client.go b/plugins/jira/tasks/api_client.go
index 3673bee5..811c0b6a 100644
--- a/plugins/jira/tasks/api_client.go
+++ b/plugins/jira/tasks/api_client.go
@@ -27,18 +27,15 @@ import (
 )
 
 func NewJiraApiClient(taskCtx core.TaskContext, connection *models.JiraConnection) (*helper.ApiAsyncClient, error) {
-	// load configuration
-	encKey := taskCtx.GetConfig(core.EncodeKeyEnvStr)
-	decodedPassword, err := core.Decrypt(encKey, connection.Password)
+	// decrypt connection first
+	err := helper.DecryptConnection(connection, "Password")
 	if err != nil {
 		return nil, fmt.Errorf("Failed to decrypt Auth AccessToken: %w", err)
 	}
-	connection.Password = decodedPassword
-	auth := connection.GetEncodedToken()
 
 	// create synchronize api client so we can calculate api rate limit dynamically
 	headers := map[string]string{
-		"Authorization": fmt.Sprintf("Basic %v", auth),
+		"Authorization": fmt.Sprintf("Basic %v", connection.GetEncodedToken()),
 	}
 	apiClient, err := helper.NewApiClient(connection.Endpoint, headers, 0, connection.Proxy, taskCtx.GetContext())
 	if err != nil {