fix: nodes format not works

api/internal/core/entity/entity.go

@@ -88,7 +88,7 @@ type Timeout struct {
 type Node struct {
 	Host     string      `json:"host,omitempty"`
 	Port     int         `json:"port,omitempty"`
-	Weight   int         `json:"weight,omitempty"`
+	Weight   int         `json:"weight"`
 	Metadata interface{} `json:"metadata,omitempty"`
 }
 

api/internal/core/entity/format.go

@@ -17,26 +17,30 @@
 package entity
 
 import (
-	"log"
 	"strconv"
 	"strings"
+
+	"github.com/apisix/manager-api/log"
 )
 
 func NodesFormat(obj interface{}) interface{} {
 	var nodes []*Node
-	if value, ok := obj.(map[string]float64); ok {
+	switch objType := obj.(type) {
+	case map[string]float64:
+		log.Infof("nodes type: %v", objType)
 		var strArr []string
+		value := obj.(map[string]float64)
 		for key, val := range value {
 			node := &Node{}
 			strArr = strings.Split(key, ":")
 			if len(strArr) != 2 {
-				log.Println("length of string array is not 2")
+				log.Warn("length of string array is not 2")
 				return obj
 			}
 
 			port, err := strconv.Atoi(strArr[1])
 			if err != nil {
-				log.Println("parse int fail:", err)
+				log.Errorf("parse int fail:", err)
 				return obj
 			}
 
@@ -46,13 +50,35 @@ func NodesFormat(obj interface{}) interface{} {
 			nodes = append(nodes, node)
 		}
 		return nodes
-	}
+	case map[string]interface{}:
+		log.Infof("nodes type: %v", objType)
+		var strArr []string
+		value := obj.(map[string]interface{})
+		for key, val := range value {
+			node := &Node{}
+			strArr = strings.Split(key, ":")
+			if len(strArr) != 2 {
+				log.Warn("length of string array is not 2")
+				return obj
+			}
 
-	if nodes, ok := obj.([]*Node); ok {
-		return nodes
-	}
+			port, err := strconv.Atoi(strArr[1])
+			if err != nil {
+				log.Errorf("parse int fail:", err)
+				return obj
+			}
 
-	if list, ok := obj.([]interface{}); ok {
+			node.Host = strArr[0]
+			node.Port = port
+			node.Weight = int(val.(float64))
+			nodes = append(nodes, node)
+		}
+		return nodes
+	case []*Node:
+		log.Infof("nodes type: %v", objType)
+		return nodes
+	case []interface{}:
+		list := obj.([]interface{})
 		for _, v := range list {
 			val := v.(map[string]interface{})
 			node := &Node{}
@@ -61,7 +87,6 @@ func NodesFormat(obj interface{}) interface{} {
 			node.Weight = int(val["weight"].(float64))
 			nodes = append(nodes, node)
 		}
-
 		return nodes
 	}
 

api/internal/core/entity/format_test.go

@@ -23,19 +23,62 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestConsumer(t *testing.T) {
-	nodesStr := `{
-    "127.0.0.1:8080": 1
-  }`
-	nodesMap := map[string]float64{}
-	err := json.Unmarshal([]byte(nodesStr), &nodesMap)
+func TestNodesFormat(t *testing.T){
+	// route data saved in ETCD
+	routeStr := `{
+        "uris": ["/*"],
+        "upstream": {
+            "type": "roundrobin",
+            "nodes": [{
+                "host": "127.0.0.1",
+                "port": 80,
+                "weight": 0
+            }]
+        }
+    }`
+
+	// bind struct
+	var  route Route
+	err := json.Unmarshal([]byte(routeStr), &route)
 	assert.Nil(t, err)
 
-	res := NodesFormat(nodesMap)
-	nodes := res.([]*Node)
+	// nodes format
+	nodes := NodesFormat(route.Upstream.Nodes)
 
-	assert.Equal(t, 1, len(nodes))
-	assert.Equal(t, "127.0.0.1", nodes[0].Host)
-	assert.Equal(t, 8080, nodes[0].Port)
-	assert.Equal(t, 1, nodes[0].Weight)
+	// json encode for client
+	res, err := json.Marshal(nodes)
+	assert.Nil(t,err)
+	jsonStr := string(res)
+	assert.Contains(t, jsonStr, `"weight":0`)
+	assert.Contains(t, jsonStr, `"port":80`)
+	assert.Contains(t, jsonStr, `"host":"127.0.0.1"`)
 }
+
+func TestNodesFormat_Map(t *testing.T){
+	// route data saved in ETCD
+	routeStr := `{
+        "uris": ["/*"],
+        "upstream": {
+            "type": "roundrobin",
+            "nodes": {"127.0.0.1:8080": 0}
+        }
+    }`
+
+	// bind struct
+	var  route Route
+	err := json.Unmarshal([]byte(routeStr), &route)
+	assert.Nil(t, err)
+
+	// nodes format
+	nodes := NodesFormat(route.Upstream.Nodes)
+
+	// json encode for client
+	res, err := json.Marshal(nodes)
+	assert.Nil(t,err)
+	jsonStr := string(res)
+	assert.Contains(t, jsonStr, `"weight":0`)
+	assert.Contains(t, jsonStr, `"port":8080`)
+	assert.Contains(t, jsonStr, `"host":"127.0.0.1"`)
+
+}
+