Test pass: news type

articles.go

@@ -68,6 +68,32 @@ func initCheck() {
 
 var respMap = make(map[string]interface{})
 
+func responseHandler(yamlContent []byte) {
+	reps := ResponseBody{}
+	err := yaml.Unmarshal(yamlContent, &reps)
+	if err == nil {
+		log.Println(reps.Kind, reps.Keyword, reps)
+		reps.MsgType = reps.Kind
+
+		switch reps.Kind {
+		case "text":
+			text := TextResponseBody{}
+			yaml.Unmarshal(yamlContent, &text)
+			respMap[reps.Keyword] = text
+		case "image":
+			image := ImageResponseBody{}
+			yaml.Unmarshal(yamlContent, &image)
+			respMap[reps.Keyword] = image
+		case "news":
+			news := NewsResponseBody{}
+			yaml.Unmarshal(yamlContent, &news)
+			respMap[reps.Keyword] = news
+		}
+	} else {
+		fmt.Println(err)
+	}
+}
+
 func update() {
 	root := CONFIG + "/management/auto-reply"
 	files, err := ioutil.ReadDir(root)
@@ -82,25 +108,7 @@ func update() {
 
 		content, err := ioutil.ReadFile(root + "/" + file.Name())
 		if err == nil {
-			reps := ResponseBody{}
-			err = yaml.Unmarshal([]byte(content), &reps)
-			if err == nil {
-				log.Println(reps.Kind, reps.Keyword, reps)
-				reps.MsgType = reps.Kind
-
-				switch reps.Kind {
-				case "text":
-					text := TextResponseBody{}
-					yaml.Unmarshal([]byte(content), &text)
-					log.Println(text)
-
-					respMap[reps.Keyword] = text
-				case "image":
-				case "link":
-				}
-			} else {
-				fmt.Println(err)
-			}
+			responseHandler(content)
 		} else {
 			log.Println("Can't read file ", file.Name())
 		}

articles_test.go

 package main
 
-import "testing"
+import (
+	"testing"
 
-func TestInitCheck(t *testing.T) {
-	initCheck()
+	"github.com/stretchr/testify/assert"
+)
+
+// func TestInitCheck(t *testing.T) {
+// 	initCheck()
+// }
+
+func TestImageResponseBody(t *testing.T) {
+	yml := `
+msgType: image
+kind: image
+
+keyword: hi
+content: say hello from jenkins.
+image:
+  mediaID: mediaId
+`
+
+	responseHandler([]byte(yml))
+
+	resp := respMap["hi"]
+	if resp == nil {
+		t.Error("Can't find response by keyword: hi.")
+	}
+
+	imageResp, ok := resp.(ImageResponseBody)
+	if !ok {
+		t.Error("Get the wrong type, should be ImageResponseBody.")
+	}
+	assert.Equal(t, imageResp.Image.MediaID, "mediaId", "ImageResponseBody parse error, can't find the correct mediaId: ", imageResp.Image.MediaID)
+}
+
+func TestNewsResponseBody(t *testing.T) {
+	yml := `
+kind: news
+keyword: about
+
+msgType: news
+articleCount: 1
+articles:
+- title: "title"
+  description: "desc"
+  picUrl: "http://pic.com"
+  url: "http://blog.com"
+`
+
+	responseHandler([]byte(yml))
+
+	resp := respMap["about"]
+	if resp == nil {
+		t.Error("Can't find response by keyword: about.")
+		return
+	}
+
+	newsResp, ok := resp.(NewsResponseBody)
+	if !ok {
+		t.Error("Get the wrong type, should be NewsResponseBody.")
+	}
+	assert.Equal(t, newsResp.Articles.Articles[0].Title, "title", "title parse error.")
 }

main.go

@@ -74,6 +74,24 @@ func procRequest(w http.ResponseWriter, r *http.Request) {
 							}
 							fmt.Fprintf(w, string(textResp))
 							return
+						} else if image, ok := resp.(ImageResponseBody); ok {
+							imageResp, err := makeImageResponseBody(textRequestBody.ToUserName, textRequestBody.FromUserName, image.Image.MediaID)
+							if err != nil {
+								log.Println("Wechat Service: makeTextResponseBody error: ", err)
+								return
+							}
+							log.Println("response", string(imageResp))
+							fmt.Fprintf(w, string(imageResp))
+							return
+						} else if news, ok := resp.(NewsResponseBody); ok {
+							newsResp, err := makeNewsResponseBody(textRequestBody.ToUserName, textRequestBody.FromUserName, news)
+							if err != nil {
+								log.Println("Wechat Service: makeNewsResponseBody error: ", err)
+								return
+							}
+							log.Println("response", string(newsResp))
+							fmt.Fprintf(w, string(newsResp))
+							return
 						} else {
 							log.Println("type error", ok)
 						}
@@ -81,15 +99,6 @@ func procRequest(w http.ResponseWriter, r *http.Request) {
 						log.Printf("can't find keyword %s\n", keyword)
 					}
 				}
-
-				responseTextBody, err := makeNewsResponseBody(textRequestBody.ToUserName,
-					textRequestBody.FromUserName,
-					"Hello, "+textRequestBody.FromUserName)
-				if err != nil {
-					log.Println("Wechat Service: makeTextResponseBody error: ", err)
-					return
-				}
-				fmt.Fprintf(w, string(responseTextBody))
 			}
 		}
 	}
@@ -105,23 +114,30 @@ func makeTextResponseBody(fromUserName, toUserName, content string) ([]byte, err
 	return xml.MarshalIndent(textResponseBody, " ", "  ")
 }
 
+func makeImageResponseBody(fromUserName, toUserName, mediaID string) ([]byte, error) {
+	imageResponseBody := &ImageResponseBody{}
+	imageResponseBody.FromUserName = fromUserName
+	imageResponseBody.ToUserName = toUserName
+	imageResponseBody.MsgType = "image"
+	imageResponseBody.CreateTime = time.Duration(time.Now().Unix())
+	imageResponseBody.Image = Image{
+		MediaID: mediaID,
+	}
+	return xml.MarshalIndent(imageResponseBody, " ", "  ")
+}
+
 func makeWelcomeResponseBody(fromUserName string, toUserName string) ([]byte, error) {
 	return makeTextResponseBody(fromUserName, toUserName, "welcome")
 }
 
-func makeNewsResponseBody(fromUserName, toUserName, content string) ([]byte, error) {
+func makeNewsResponseBody(fromUserName, toUserName string, news NewsResponseBody) ([]byte, error) {
 	newsResponseBody := &NewsResponseBody{}
 	newsResponseBody.FromUserName = fromUserName
 	newsResponseBody.ToUserName = toUserName
 	newsResponseBody.MsgType = "news"
 	newsResponseBody.ArticleCount = 1
 	newsResponseBody.Articles = Articles{
-		Articles: []Article{{
-			Title:       "来自 Jenkins 官方的消息",
-			Description: "来自 Jenkins 官方的消息",
-			PicUrl:      "https://raw.githubusercontent.com/jenkins-infra/wechat/master/images/vscode-pipeline-linter/example1.gif",
-			Url:         "https://mp.weixin.qq.com/s/4pktvfQ3tJZgqY--VgNgZQ",
-		}},
+		Articles: news.Articles.Articles,
 	}
 	newsResponseBody.CreateTime = time.Duration(time.Now().Unix())
 	return xml.MarshalIndent(newsResponseBody, " ", "  ")

types.go

@@ -18,37 +18,45 @@ type TextRequestBody struct {
 
 type ResponseBody struct {
 	Keyword string `json:"keyword"`
-	MsgType string `json:"msgType"`
 	Kind    string `json:"kind"`
-}
 
-type TextResponseBody struct {
-	ResponseBody
-	XMLName      xml.Name `xml:"xml"`
+	MsgType      string `json:"msgType" yaml:"msgType" xml:"MsgType"`
 	ToUserName   string
 	FromUserName string
 	CreateTime   time.Duration
+}
+
+type TextResponseBody struct {
+	ResponseBody `yaml:",inline"`
+	XMLName      xml.Name `xml:"xml"`
 	Content      string
 }
 
 type NewsResponseBody struct {
-	ResponseBody
+	ResponseBody `yaml:",inline"`
 	XMLName      xml.Name `xml:"xml"`
-	ToUserName   string
-	FromUserName string
-	CreateTime   time.Duration
-	ArticleCount int
-	Articles     Articles
+	ArticleCount int      `json:"articleCount" yaml:"articleCount" xml:"ArticleCount"`
+	Articles     Articles `yaml:",inline"`
+}
+
+type ImageResponseBody struct {
+	ResponseBody `yaml:",inline"`
+	XMLName      xml.Name `xml:"xml"`
+	Image        Image
 }
 
 type Articles struct {
-	XMLName  xml.Name  `xml:"Articles"`
+	// XMLName  xml.Name  `xml:"Articles"`
 	Articles []Article `xml:"item"`
 }
 
+type Image struct {
+	MediaID string `json:"mediaId" yaml:"mediaID" xml:"MediaId"`
+}
+
 type Article struct {
 	Title       string
 	Description string
-	PicUrl      string
+	PicUrl      string `json:"picUrl" yaml:"picUrl" xml:"PicUrl"`
 	Url         string
 }