From 41ac45d16e553e8925ffacfb9b047c836b85cffc Mon Sep 17 00:00:00 2001 From: David Zhang Date: Tue, 2 Jan 2024 21:16:21 +0800 Subject: [PATCH] refactor: put different middlewares under their own namespaces --- challenge.go | 47 ++++++++ challenge_test.go | 52 +++++++++ event_v1.go | 57 ++++++++++ event_v1_test.go | 170 ++++++++++++++++++++++++++++ event_v2.go | 55 +++++++++ event_v2_test.go | 65 +++++++++++ gin.go | 150 +++---------------------- gin_test.go | 281 ++++------------------------------------------ property_test.go | 31 ----- 9 files changed, 485 insertions(+), 423 deletions(-) create mode 100644 challenge.go create mode 100644 challenge_test.go create mode 100644 event_v1.go create mode 100644 event_v1_test.go create mode 100644 event_v2.go create mode 100644 event_v2_test.go delete mode 100644 property_test.go diff --git a/challenge.go b/challenge.go new file mode 100644 index 0000000..e0b9f38 --- /dev/null +++ b/challenge.go @@ -0,0 +1,47 @@ +package larkgin + +import ( + "encoding/json" + "log" + "net/http" + + "github.com/gin-gonic/gin" + "github.com/go-lark/lark" +) + +// LarkChallengeHandler Lark challenge handler +func (opt LarkMiddleware) LarkChallengeHandler() gin.HandlerFunc { + return func(c *gin.Context) { + defer c.Next() + if opt.enableURLBinding && c.Request.URL.String() != opt.urlPrefix { + // url not match just pass + return + } + + body, err := fetchBody(c) + if err != nil { + return + } + var inputBody = body + if opt.enableEncryption { + decryptedData, err := opt.decodeEncryptedJSON(body) + if err != nil { + log.Println("Decrypt failed:", err) + return + } + inputBody = decryptedData + } + + var challenge lark.EventChallenge + err = json.Unmarshal(inputBody, &challenge) + if err != nil { + return + } + if challenge.Type == "url_verification" { + log.Println("Handling challenge:", challenge.Challenge) + c.AbortWithStatusJSON(http.StatusOK, gin.H{ + "challenge": challenge.Challenge, + }) + } + } +} diff --git a/challenge_test.go b/challenge_test.go new file mode 100644 index 0000000..d9062fa --- /dev/null +++ b/challenge_test.go @@ -0,0 +1,52 @@ +package larkgin + +import ( + "encoding/json" + "testing" + + "github.com/gin-gonic/gin" + "github.com/go-lark/lark" + "github.com/stretchr/testify/assert" +) + +func TestChallengePassed(t *testing.T) { + var ( + r = gin.Default() + middleware = NewLarkMiddleware() + ) + r.Use(middleware.LarkChallengeHandler()) + r.POST("/", func(c *gin.Context) { + // do nothing + }) + + message := lark.EventChallenge{ + Challenge: "test", + Type: "url_verification", + } + resp := performRequest(r, "POST", "/", message) + var respData lark.EventChallengeReq + if assert.NotNil(t, resp.Body) { + json.NewDecoder(resp.Body).Decode(&respData) + assert.Equal(t, "test", respData.Challenge) + } +} + +func TestChallengeMismatch(t *testing.T) { + r := gin.Default() + middleware := NewLarkMiddleware().BindURLPrefix("/abc") + r.Use(middleware.LarkChallengeHandler()) + r.POST("/", func(c *gin.Context) { + // do nothing + }) + + message := lark.EventChallenge{ + Challenge: "test", + Type: "url_verification", + } + resp := performRequest(r, "POST", "/", message) + var respData lark.EventChallenge + if assert.NotNil(t, resp.Body) { + err := json.NewDecoder(resp.Body).Decode(&respData) + assert.Error(t, err) + } +} diff --git a/event_v1.go b/event_v1.go new file mode 100644 index 0000000..8a12959 --- /dev/null +++ b/event_v1.go @@ -0,0 +1,57 @@ +package larkgin + +import ( + "encoding/json" + "log" + + "github.com/gin-gonic/gin" + "github.com/go-lark/lark" +) + +// GetMessage from gin context +func (opt LarkMiddleware) GetMessage(c *gin.Context) (*lark.EventMessage, bool) { + if message, ok := c.Get(opt.messageKey); ok { + msg, ok := message.(lark.EventMessage) + return &msg, ok + } + + return nil, false +} + +// LarkMessageHandler Lark message handler +func (opt LarkMiddleware) LarkMessageHandler() gin.HandlerFunc { + return func(c *gin.Context) { + defer c.Next() + if opt.enableURLBinding && c.Request.URL.String() != opt.urlPrefix { + // url not match just pass + return + } + + body, err := fetchBody(c) + if err != nil { + return + } + var inputBody = body + if opt.enableEncryption { + decryptedData, err := opt.decodeEncryptedJSON(body) + if err != nil { + log.Println("Decrypt failed:", err) + return + } + inputBody = decryptedData + } + + var message lark.EventMessage + err = json.Unmarshal(inputBody, &message) + if err != nil { + return + } + + if opt.enableTokenVerification && message.Token != opt.verificationToken { + log.Println("Token verification failed") + return + } + log.Println("Handling message:", message.EventType) + c.Set(opt.messageKey, message) + } +} diff --git a/event_v1_test.go b/event_v1_test.go new file mode 100644 index 0000000..44e3487 --- /dev/null +++ b/event_v1_test.go @@ -0,0 +1,170 @@ +package larkgin + +import ( + "encoding/json" + "testing" + + "github.com/gin-gonic/gin" + "github.com/go-lark/lark" + "github.com/stretchr/testify/assert" +) + +func TestMessageStandard(t *testing.T) { + var ( + r = gin.Default() + middleware = NewLarkMiddleware() + + ok bool + m *lark.EventMessage + ) + r.Use(middleware.LarkMessageHandler()) + r.POST("/", func(c *gin.Context) { + m, ok = middleware.GetMessage(c) + }) + + message := lark.EventMessage{ + Timestamp: "", + Token: "", + EventType: "event_callback", + Event: lark.EventBody{ + Type: "message", + ChatType: "private", + MsgType: "text", + OpenID: "ou_08198ccd6a37644b49f4789c92369c80", + Text: "tlb", + Title: "", + OpenMessageID: "", + ImageKey: "", + ImageURL: "", + }, + } + performRequest(r, "POST", "/", message) + assert.True(t, ok) + assert.Equal(t, "tlb", m.Event.Text) +} + +func TestMessageMismatch(t *testing.T) { + r := gin.Default() + middleware := NewLarkMiddleware().BindURLPrefix("/abc") + r.Use(middleware.LarkMessageHandler()) + r.POST("/", func(c *gin.Context) { + // do nothing + }) + + message := lark.EventMessage{ + Timestamp: "", + Token: "", + EventType: "event_callback", + Event: lark.EventBody{ + Type: "message", + ChatType: "private", + MsgType: "text", + OpenID: "ou_08198ccd6a37644b49f4789c92369c80", + Text: "tlb", + Title: "", + OpenMessageID: "", + ImageKey: "", + ImageURL: "", + }, + } + resp := performRequest(r, "POST", "/", message) + var respData lark.EventMessage + if assert.NotNil(t, resp.Body) { + err := json.NewDecoder(resp.Body).Decode(&respData) + assert.Error(t, err) + } +} + +func TestMessaggeEncryted(t *testing.T) { + var ( + r = gin.Default() + middleware = NewLarkMiddleware().WithEncryption("ocTiICyJdYyvxD6gLkYdsewM41Qc48bx") + + ok bool + m *lark.EventMessage + + encryptText = "dSb7qqosP3fKQfSk1+wHkhmKX6ucVAZg2/BrkAe5ETqFTP6X/gvzWkVt7YtecaGuN5PuuYECHHEr1xvSXeIJ0Ijr1g85o8EwK12IcatCNhyHb+rOoPRrm4/BYOHVEmp8nmnOzZBWRBnqzAj7qZh5+qBcO1z7XaU70uRXW7CZQCAZF/MY/hEtgIzcQKYiP4J3G7jMJEfj9OWqtaKMTOCJWz/JG0vpP6Mj5dv2P1qvgt+JjdgpsYXqAoO+T7ZbEW7k7olXLhN66osKADTSUP7RsPROfsEywuPagZXSIe0QXZtayDazcjPrfJRtc59U2j2I43+dVw0tJT3U//Wik4ISq3g8RCAJKnRl4AMJKpWzEq3qU27aRQlNj032cQQV28d4ji6AybnGuIvJzhtVnYZ6/2Uvlt1x9+11M/qDLftVzf5n2tAu1zdDlU1Lu3ctPbD0Q1wmTQ0cEJYXXPivtxv+jwqdRY3OTU6F1OlMiVOyKD0RIzudpivNyfYSreIEIa+LwGHIcXQE3pSgn//LFrJ5TgRen0cF4F1n6w0dtTMqM3PvCdSaDgIv8IHgKgyLYiT7U8aFLAvbLMw0Vutw7l2efL1P4Mv8gfIXHVpvVTkSkVa/kYrxQEtNO8A4lYghR6fB5CTiK23O5GQEd65A/R9s/eduaAkzC1Csp4H0NFX0CFxlF0/QJB8i72v3tBFppo/5U2Pfs0Drx2uYI4ijalv9XDvYpwiFxLiwEx35/9fKJ6nND7CSi1ShWdkkbVkN+fPE/r9suWHZtw3r1TPI3pEAWo3sV3xMnmpTnh6xp2CPi10ZIKCU0fN0Un3a1kEXIiTcpu02Y60trr8HiTUa0kUgQhbHg9seDGXmDrcTbm8oGFk/1HMQ/DA6S9Fb7lIBKEMbVKQf01XreAJZtKtCT2FSlNu49I/ho2sN9ueUWkAVfdR95AezX2oNmZI2yTyJD2B+B7aTPWBW6+f/nS7t9Ehc/l6cGgVC5/2w6pZsIeHeRSqaYe3x+YocE/gFwWXfkJ9AoJMz2us3ZRBQmKY1IfOK19KAyMuSyJ/YrQmLCl0Oroxg86nTH2nFpo4j85V5nW9e9YpZW6+6jb8vROAcoQN9yJA2o2hkw3Us9JvCpDZ7Y0JDoDzPq0JiBwKc7NMe5SVNZ++FZWKn7NR/vYfM5bAqew77a46P6sTVJBjwhK1OYVNUSmSdZ+jv2jqgSj1oJpwZWwmwwzQCrHV6h7VbzhgP7XliJKEj6yIR4a5vfRpTalI=" + ) + + r.Use(middleware.LarkMessageHandler()) + r.POST("/", func(c *gin.Context) { + m, ok = middleware.GetMessage(c) + }) + + encryptMessage := lark.EncryptedReq{ + Encrypt: encryptText, + } + performRequest(r, "POST", "/", encryptMessage) + assert.True(t, ok) + assert.Equal(t, "hello", m.Event.Text) + assert.Equal(t, "9378d8f0122244e0920644d114e761d5", m.Token) +} + +func TestMessageRawFetch(t *testing.T) { + var ( + r = gin.Default() + middleware = NewLarkMiddleware() + + ok bool + m lark.EventMessage + ) + r.Use(middleware.LarkMessageHandler()) + r.POST("/", func(c *gin.Context) { + message, _ := c.Get(defaultLarkMessageKey) + m, ok = message.(lark.EventMessage) + }) + + message := lark.EventMessage{ + Timestamp: "", + Token: "", + EventType: "event_callback", + Event: lark.EventBody{ + Type: "message", + ChatType: "private", + MsgType: "text", + OpenID: "ou_08198ccd6a37644b49f4789c92369c80", + Text: "tlb", + Title: "", + OpenMessageID: "", + ImageKey: "", + ImageURL: "", + }, + } + performRequest(r, "POST", "/", message) + assert.True(t, ok) + assert.Equal(t, "tlb", m.Event.Text) +} + +func TestMessageWithTokenVerifcation(t *testing.T) { + var ( + r = gin.Default() + middleware = NewLarkMiddleware().WithTokenVerification("abc") + + ok bool + m *lark.EventMessage + ) + r.Use(middleware.LarkMessageHandler()) + r.POST("/", func(c *gin.Context) { + m, ok = middleware.GetMessage(c) + }) + + message := lark.EventMessage{ + Timestamp: "", + Token: "abc1", + EventType: "event_callback", + Event: lark.EventBody{ + Type: "message", + ChatType: "private", + MsgType: "text", + OpenID: "ou_08198ccd6a37644b49f4789c92369c80", + Text: "tlb", + Title: "", + OpenMessageID: "", + ImageKey: "", + ImageURL: "", + }, + } + performRequest(r, "POST", "/", message) + assert.False(t, ok) + assert.Nil(t, m) +} diff --git a/event_v2.go b/event_v2.go new file mode 100644 index 0000000..536872d --- /dev/null +++ b/event_v2.go @@ -0,0 +1,55 @@ +package larkgin + +import ( + "encoding/json" + "log" + + "github.com/gin-gonic/gin" + "github.com/go-lark/lark" +) + +// GetEvent should call GetEvent if you're using EventV2 +func (opt LarkMiddleware) GetEvent(c *gin.Context) (*lark.EventV2, bool) { + if message, ok := c.Get(opt.messageKey); ok { + event, ok := message.(lark.EventV2) + if event.Schema != "2.0" { + return nil, false + } + return &event, ok + } + + return nil, false +} + +// LarkEventHandler handle lark event v2 +func (opt LarkMiddleware) LarkEventHandler() gin.HandlerFunc { + return func(c *gin.Context) { + defer c.Next() + body, err := fetchBody(c) + if err != nil { + return + } + var inputBody = body + if opt.enableEncryption { + decryptedData, err := opt.decodeEncryptedJSON(body) + if err != nil { + log.Println("Decrypt failed:", err) + return + } + inputBody = decryptedData + } + + var event lark.EventV2 + err = json.Unmarshal(inputBody, &event) + if err != nil { + log.Println(err) + return + } + if opt.enableTokenVerification && event.Header.Token != opt.verificationToken { + log.Println("Token verification failed") + return + } + log.Println("Handling event:", event.Header.EventType) + c.Set(opt.messageKey, event) + } +} diff --git a/event_v2_test.go b/event_v2_test.go new file mode 100644 index 0000000..813a02a --- /dev/null +++ b/event_v2_test.go @@ -0,0 +1,65 @@ +package larkgin + +import ( + "testing" + + "github.com/gin-gonic/gin" + "github.com/go-lark/lark" + "github.com/stretchr/testify/assert" +) + +func TestEventV2(t *testing.T) { + var ( + r = gin.Default() + middleware = NewLarkMiddleware() + + ok bool + event *lark.EventV2 + ) + r.Use(middleware.LarkEventHandler()) + r.POST("/", func(c *gin.Context) { + event, ok = middleware.GetEvent(c) + }) + + message := map[string]interface{}{ + "schema": "2.0", + "header": map[string]interface{}{ + "event_id": "8295112f4e107daafa9aa169e746c627", + "token": "Si0qr61OaX02zPtzudllLgSDOXaKyNy0", + "create_time": "1641385820880", + "event_type": "im.message.receive_v1", + "tenant_key": "7", + "app_id": "6", + }, + "event": map[string]interface{}{ + "message": map[string]interface{}{ + "chat_id": "oc_ae7f3952a9b28588aeac46c9853d25d3", + "chat_type": "p2p", + "content": "{\"text\":\"333\"}", + "create_time": "1641385820771", + "message_id": "om_6ff2cff41a3e9248bbb19bf0e4762e6e", + "message_type": "text", + }, + "sender": map[string]interface{}{ + "sender_id": map[string]interface{}{ + "open_id": "ou_4f75b532aff410181e93552ad0532072", + "union_id": "on_2312aab89ab7c87beb9a443b2f3b1342", + "user_id": "4gbb63af", + }, + "sender_type": "user", + "tenant_key": "736588c9260f175d", + }, + }, + } + performRequest(r, "POST", "/", message) + assert.True(t, ok) + if assert.NotNil(t, event) { + assert.Equal(t, "im.message.receive_v1", event.Header.EventType) + assert.Equal(t, "2.0", event.Schema) + assert.Equal(t, "6", event.Header.AppID) + msg, err := event.GetMessageReceived() + if assert.NoError(t, err) { + assert.Equal(t, "{\"text\":\"333\"}", msg.Message.Content) + } + } +} diff --git a/gin.go b/gin.go index 11eadaf..764fcd0 100644 --- a/gin.go +++ b/gin.go @@ -1,20 +1,23 @@ +// Package larkgin is gin middleware for go-lark/lark package larkgin import ( - "encoding/json" - "log" - "net/http" - - "github.com/gin-gonic/gin" "github.com/go-lark/lark" ) -// DefaultLarkMessageKey still public for compatibility +// DefaultLarkMessageKey compat legacy versions +// not use in this repo right now const DefaultLarkMessageKey = "go-lark-message" +const ( + defaultLarkMessageKey = "go-lark-message" + defaultLarkCardKey = "go-lark-card" +) + // LarkMiddleware . type LarkMiddleware struct { messageKey string + cardKey string enableTokenVerification bool verificationToken string @@ -29,7 +32,8 @@ type LarkMiddleware struct { // NewLarkMiddleware . func NewLarkMiddleware() *LarkMiddleware { return &LarkMiddleware{ - messageKey: DefaultLarkMessageKey, + messageKey: defaultLarkMessageKey, + cardKey: defaultLarkCardKey, } } @@ -64,133 +68,9 @@ func (opt *LarkMiddleware) SetMessageKey(key string) *LarkMiddleware { return opt } -// GetMessage from gin context -func (opt LarkMiddleware) GetMessage(c *gin.Context) (msg *lark.EventMessage, ok bool) { - if message, ok := c.Get(opt.messageKey); ok { - msg, ok := message.(lark.EventMessage) - return &msg, ok - } - - return nil, false -} - -// GetEvent should call GetEvent if you're using EventV2 -func (opt LarkMiddleware) GetEvent(c *gin.Context) (*lark.EventV2, bool) { - if message, ok := c.Get(opt.messageKey); ok { - event, ok := message.(lark.EventV2) - if event.Schema != "2.0" { - return nil, false - } - return &event, ok - } - - return nil, false -} - -// LarkEventHandler handle lark event v2 -func (opt LarkMiddleware) LarkEventHandler() gin.HandlerFunc { - return func(c *gin.Context) { - defer c.Next() - body, err := fetchBody(c) - if err != nil { - return - } - var inputBody []byte = body - if opt.enableEncryption { - decryptedData, err := opt.decodeEncryptedJSON(body) - if err != nil { - log.Println("Decrypt failed:", err) - return - } - inputBody = decryptedData - } - - var event lark.EventV2 - err = json.Unmarshal(inputBody, &event) - if err != nil { - log.Println(err) - return - } - if opt.enableTokenVerification && event.Header.Token != opt.verificationToken { - log.Println("Token verification failed") - return - } - log.Println("Handling event:", event.Header.EventType) - c.Set(opt.messageKey, event) - } -} +// SetCardKey . +func (opt *LarkMiddleware) SetCardKey(key string) *LarkMiddleware { + opt.cardKey = key -// LarkMessageHandler Lark message handler -func (opt LarkMiddleware) LarkMessageHandler() gin.HandlerFunc { - return func(c *gin.Context) { - defer c.Next() - if opt.enableURLBinding && c.Request.URL.String() != opt.urlPrefix { - // url not match just pass - return - } - - body, err := fetchBody(c) - if err != nil { - return - } - var inputBody []byte = body - if opt.enableEncryption { - decryptedData, err := opt.decodeEncryptedJSON(body) - if err != nil { - log.Println("Decrypt failed:", err) - return - } - inputBody = decryptedData - } - - var message lark.EventMessage - err = json.Unmarshal(inputBody, &message) - if err != nil { - return - } - - if opt.enableTokenVerification && message.Token != opt.verificationToken { - log.Println("Token verification failed") - return - } - log.Println("Handling message:", message.EventType) - c.Set(opt.messageKey, message) - } -} - -// LarkChallengeHandler Lark challenge handler -func (opt LarkMiddleware) LarkChallengeHandler() gin.HandlerFunc { - return func(c *gin.Context) { - defer c.Next() - if opt.enableURLBinding && c.Request.URL.String() != opt.urlPrefix { - // url not match just pass - return - } - - body, err := fetchBody(c) - if err != nil { - return - } - var inputBody []byte = body - if opt.enableEncryption { - decryptedData, err := opt.decodeEncryptedJSON(body) - if err != nil { - log.Println("Decrypt failed:", err) - return - } - inputBody = decryptedData - } - - var challenge lark.EventChallengeReq - err = json.Unmarshal(inputBody, &challenge) - if err != nil { - return - } - if challenge.Type == "url_verification" { - log.Println("Handling challenge:", challenge.Challenge) - c.AbortWithStatusJSON(http.StatusOK, gin.H{ - "challenge": challenge.Challenge, - }) - } - } + return opt } diff --git a/gin_test.go b/gin_test.go index 75f819a..ef67b03 100644 --- a/gin_test.go +++ b/gin_test.go @@ -7,7 +7,6 @@ import ( "net/http/httptest" "testing" - "github.com/gin-gonic/gin" "github.com/go-lark/lark" "github.com/stretchr/testify/assert" ) @@ -21,260 +20,28 @@ func performRequest(r http.Handler, method, path string, body interface{}) *http return w } -func TestMessageStandard(t *testing.T) { - var ( - r = gin.Default() - middleware = NewLarkMiddleware() - - ok bool - m *lark.EventMessage - ) - r.Use(middleware.LarkMessageHandler()) - r.POST("/", func(c *gin.Context) { - m, ok = middleware.GetMessage(c) - }) - - message := lark.EventMessage{ - Timestamp: "", - Token: "", - EventType: "event_callback", - Event: lark.EventBody{ - Type: "message", - ChatType: "private", - MsgType: "text", - OpenID: "ou_08198ccd6a37644b49f4789c92369c80", - Text: "tlb", - Title: "", - OpenMessageID: "", - ImageKey: "", - ImageURL: "", - }, - } - performRequest(r, "POST", "/", message) - assert.True(t, ok) - assert.Equal(t, "tlb", m.Event.Text) -} - -func TestMessageMismatch(t *testing.T) { - r := gin.Default() - middleware := NewLarkMiddleware().BindURLPrefix("/abc") - r.Use(middleware.LarkMessageHandler()) - r.POST("/", func(c *gin.Context) { - // do nothing - }) - - message := lark.EventMessage{ - Timestamp: "", - Token: "", - EventType: "event_callback", - Event: lark.EventBody{ - Type: "message", - ChatType: "private", - MsgType: "text", - OpenID: "ou_08198ccd6a37644b49f4789c92369c80", - Text: "tlb", - Title: "", - OpenMessageID: "", - ImageKey: "", - ImageURL: "", - }, - } - resp := performRequest(r, "POST", "/", message) - var respData lark.EventMessage - if assert.NotNil(t, resp.Body) { - err := json.NewDecoder(resp.Body).Decode(&respData) - assert.Error(t, err) - } -} - -func TestMessaggeEncryted(t *testing.T) { - var ( - r = gin.Default() - middleware = NewLarkMiddleware().WithEncryption("ocTiICyJdYyvxD6gLkYdsewM41Qc48bx") - - ok bool - m *lark.EventMessage - - encryptText = "dSb7qqosP3fKQfSk1+wHkhmKX6ucVAZg2/BrkAe5ETqFTP6X/gvzWkVt7YtecaGuN5PuuYECHHEr1xvSXeIJ0Ijr1g85o8EwK12IcatCNhyHb+rOoPRrm4/BYOHVEmp8nmnOzZBWRBnqzAj7qZh5+qBcO1z7XaU70uRXW7CZQCAZF/MY/hEtgIzcQKYiP4J3G7jMJEfj9OWqtaKMTOCJWz/JG0vpP6Mj5dv2P1qvgt+JjdgpsYXqAoO+T7ZbEW7k7olXLhN66osKADTSUP7RsPROfsEywuPagZXSIe0QXZtayDazcjPrfJRtc59U2j2I43+dVw0tJT3U//Wik4ISq3g8RCAJKnRl4AMJKpWzEq3qU27aRQlNj032cQQV28d4ji6AybnGuIvJzhtVnYZ6/2Uvlt1x9+11M/qDLftVzf5n2tAu1zdDlU1Lu3ctPbD0Q1wmTQ0cEJYXXPivtxv+jwqdRY3OTU6F1OlMiVOyKD0RIzudpivNyfYSreIEIa+LwGHIcXQE3pSgn//LFrJ5TgRen0cF4F1n6w0dtTMqM3PvCdSaDgIv8IHgKgyLYiT7U8aFLAvbLMw0Vutw7l2efL1P4Mv8gfIXHVpvVTkSkVa/kYrxQEtNO8A4lYghR6fB5CTiK23O5GQEd65A/R9s/eduaAkzC1Csp4H0NFX0CFxlF0/QJB8i72v3tBFppo/5U2Pfs0Drx2uYI4ijalv9XDvYpwiFxLiwEx35/9fKJ6nND7CSi1ShWdkkbVkN+fPE/r9suWHZtw3r1TPI3pEAWo3sV3xMnmpTnh6xp2CPi10ZIKCU0fN0Un3a1kEXIiTcpu02Y60trr8HiTUa0kUgQhbHg9seDGXmDrcTbm8oGFk/1HMQ/DA6S9Fb7lIBKEMbVKQf01XreAJZtKtCT2FSlNu49I/ho2sN9ueUWkAVfdR95AezX2oNmZI2yTyJD2B+B7aTPWBW6+f/nS7t9Ehc/l6cGgVC5/2w6pZsIeHeRSqaYe3x+YocE/gFwWXfkJ9AoJMz2us3ZRBQmKY1IfOK19KAyMuSyJ/YrQmLCl0Oroxg86nTH2nFpo4j85V5nW9e9YpZW6+6jb8vROAcoQN9yJA2o2hkw3Us9JvCpDZ7Y0JDoDzPq0JiBwKc7NMe5SVNZ++FZWKn7NR/vYfM5bAqew77a46P6sTVJBjwhK1OYVNUSmSdZ+jv2jqgSj1oJpwZWwmwwzQCrHV6h7VbzhgP7XliJKEj6yIR4a5vfRpTalI=" - ) - - r.Use(middleware.LarkMessageHandler()) - r.POST("/", func(c *gin.Context) { - m, ok = middleware.GetMessage(c) - }) - - encryptMessage := lark.EncryptedReq{ - Encrypt: encryptText, - } - performRequest(r, "POST", "/", encryptMessage) - assert.True(t, ok) - assert.Equal(t, "hello", m.Event.Text) - assert.Equal(t, "9378d8f0122244e0920644d114e761d5", m.Token) -} - -func TestMessageRawFetch(t *testing.T) { - var ( - r = gin.Default() - middleware = NewLarkMiddleware() - - ok bool - m lark.EventMessage - ) - r.Use(middleware.LarkMessageHandler()) - r.POST("/", func(c *gin.Context) { - message, _ := c.Get(DefaultLarkMessageKey) - m, ok = message.(lark.EventMessage) - }) - - message := lark.EventMessage{ - Timestamp: "", - Token: "", - EventType: "event_callback", - Event: lark.EventBody{ - Type: "message", - ChatType: "private", - MsgType: "text", - OpenID: "ou_08198ccd6a37644b49f4789c92369c80", - Text: "tlb", - Title: "", - OpenMessageID: "", - ImageKey: "", - ImageURL: "", - }, - } - performRequest(r, "POST", "/", message) - assert.True(t, ok) - assert.Equal(t, "tlb", m.Event.Text) -} - -func TestMessageWithTokenVerifcation(t *testing.T) { - var ( - r = gin.Default() - middleware = NewLarkMiddleware().WithTokenVerification("abc") - - ok bool - m *lark.EventMessage - ) - r.Use(middleware.LarkMessageHandler()) - r.POST("/", func(c *gin.Context) { - m, ok = middleware.GetMessage(c) - }) - - message := lark.EventMessage{ - Timestamp: "", - Token: "abc1", - EventType: "event_callback", - Event: lark.EventBody{ - Type: "message", - ChatType: "private", - MsgType: "text", - OpenID: "ou_08198ccd6a37644b49f4789c92369c80", - Text: "tlb", - Title: "", - OpenMessageID: "", - ImageKey: "", - ImageURL: "", - }, - } - performRequest(r, "POST", "/", message) - assert.False(t, ok) - assert.Nil(t, m) -} - -func TestChallengePassed(t *testing.T) { - var ( - r = gin.Default() - middleware = NewLarkMiddleware() - ) - r.Use(middleware.LarkChallengeHandler()) - r.POST("/", func(c *gin.Context) { - // do nothing - }) - - message := lark.EventChallengeReq{ - Challenge: "test", - Type: "url_verification", - } - resp := performRequest(r, "POST", "/", message) - var respData lark.EventChallengeReq - if assert.NotNil(t, resp.Body) { - json.NewDecoder(resp.Body).Decode(&respData) - assert.Equal(t, "test", respData.Challenge) - } -} - -func TestChallengeMismatch(t *testing.T) { - r := gin.Default() - middleware := NewLarkMiddleware().BindURLPrefix("/abc") - r.Use(middleware.LarkChallengeHandler()) - r.POST("/", func(c *gin.Context) { - // do nothing - }) - - message := lark.EventChallengeReq{ - Challenge: "test", - Type: "url_verification", - } - resp := performRequest(r, "POST", "/", message) - var respData lark.EventChallengeReq - if assert.NotNil(t, resp.Body) { - err := json.NewDecoder(resp.Body).Decode(&respData) - assert.Error(t, err) - } -} - -func TestEventV2(t *testing.T) { - var ( - r = gin.Default() - middleware = NewLarkMiddleware() - - ok bool - event *lark.EventV2 - ) - r.Use(middleware.LarkEventHandler()) - r.POST("/", func(c *gin.Context) { - event, ok = middleware.GetEvent(c) - }) - - message := map[string]interface{}{ - "schema": "2.0", - "header": map[string]interface{}{ - "event_id": "8295112f4e107daafa9aa169e746c627", - "token": "Si0qr61OaX02zPtzudllLgSDOXaKyNy0", - "create_time": "1641385820880", - "event_type": "im.message.receive_v1", - "tenant_key": "7", - "app_id": "6", - }, - "event": map[string]interface{}{ - "message": map[string]interface{}{ - "chat_id": "oc_ae7f3952a9b28588aeac46c9853d25d3", - "chat_type": "p2p", - "content": "{\"text\":\"333\"}", - "create_time": "1641385820771", - "message_id": "om_6ff2cff41a3e9248bbb19bf0e4762e6e", - "message_type": "text", - }, - "sender": map[string]interface{}{ - "sender_id": map[string]interface{}{ - "open_id": "ou_4f75b532aff410181e93552ad0532072", - "union_id": "on_2312aab89ab7c87beb9a443b2f3b1342", - "user_id": "4gbb63af", - }, - "sender_type": "user", - "tenant_key": "736588c9260f175d", - }, - }, - } - performRequest(r, "POST", "/", message) - assert.True(t, ok) - if assert.NotNil(t, event) { - assert.Equal(t, "im.message.receive_v1", event.Header.EventType) - assert.Equal(t, "2.0", event.Schema) - assert.Equal(t, "6", event.Header.AppID) - msg, err := event.GetMessageReceived() - if assert.NoError(t, err) { - assert.Equal(t, "{\"text\":\"333\"}", msg.Message.Content) - } - } +func TestLarkMiddleware(t *testing.T) { + lm := NewLarkMiddleware() + assert.False(t, lm.enableEncryption) + assert.Empty(t, lm.encryptKey) + assert.False(t, lm.enableTokenVerification) + assert.Empty(t, lm.verificationToken) + assert.False(t, lm.enableURLBinding) + assert.Empty(t, lm.urlPrefix) + assert.Equal(t, defaultLarkMessageKey, lm.messageKey) + assert.Equal(t, defaultLarkCardKey, lm.cardKey) + + lm.SetMessageKey("aaa") + assert.Equal(t, "aaa", lm.messageKey) + lm.SetCardKey("bbb") + assert.Equal(t, "bbb", lm.cardKey) + lm.WithEncryption("bbb") + assert.True(t, lm.enableEncryption) + assert.Equal(t, lark.EncryptKey("bbb"), lm.encryptKey) + lm.WithTokenVerification("ccc") + assert.True(t, lm.enableTokenVerification) + assert.Equal(t, "ccc", lm.verificationToken) + lm.BindURLPrefix("/ddd") + assert.True(t, lm.enableURLBinding) + assert.Equal(t, "/ddd", lm.urlPrefix) } diff --git a/property_test.go b/property_test.go deleted file mode 100644 index 9ee0c15..0000000 --- a/property_test.go +++ /dev/null @@ -1,31 +0,0 @@ -package larkgin - -import ( - "testing" - - "github.com/go-lark/lark" - "github.com/stretchr/testify/assert" -) - -func TestLarkMiddleware(t *testing.T) { - lm := NewLarkMiddleware() - assert.False(t, lm.enableEncryption) - assert.Empty(t, lm.encryptKey) - assert.False(t, lm.enableTokenVerification) - assert.Empty(t, lm.verificationToken) - assert.False(t, lm.enableURLBinding) - assert.Empty(t, lm.urlPrefix) - assert.Equal(t, DefaultLarkMessageKey, lm.messageKey) - - lm.SetMessageKey("aaa") - assert.Equal(t, "aaa", lm.messageKey) - lm.WithEncryption("bbb") - assert.True(t, lm.enableEncryption) - assert.Equal(t, lark.EncryptKey("bbb"), lm.encryptKey) - lm.WithTokenVerification("ccc") - assert.True(t, lm.enableTokenVerification) - assert.Equal(t, "ccc", lm.verificationToken) - lm.BindURLPrefix("/ddd") - assert.True(t, lm.enableURLBinding) - assert.Equal(t, "/ddd", lm.urlPrefix) -}