Files
dobotai-platform/internal/channels/dingtalk/webhook_test.go
2026-07-20 13:01:59 +08:00

172 lines
5.4 KiB
Go

package dingtalk
import (
"context"
"crypto/tls"
"encoding/json"
"io"
"net/http"
"net/http/httptest"
"net/url"
"strings"
"testing"
)
func newTestSender(t *testing.T, client *http.Client) *WebhookSender {
t.Helper()
sender, err := NewWebhookSender(client)
if err != nil {
t.Fatalf("NewWebhookSender: %v", err)
}
return sender
}
func TestWebhookSenderRejectsInvalidURLs(t *testing.T) {
sender := newTestSender(t, http.DefaultClient)
cases := map[string]string{
"http not https": "http://oapi.dingtalk.com/robot/send?access_token=x",
"userinfo": "https://user:pass@oapi.dingtalk.com/robot/send?access_token=x",
"arbitrary public host": "https://evil.example.com/robot/send",
"non-default port": "https://oapi.dingtalk.com:8443/robot/send",
"empty url": "",
"no host": "https:///robot/send",
}
for name, raw := range cases {
t.Run(name, func(t *testing.T) {
if err := sender.SendMarkdown(context.Background(), raw, "t", "hello"); err == nil {
t.Fatalf("expected rejection for %q", raw)
}
})
}
}
func TestWebhookSenderRejectsRedirect(t *testing.T) {
var finalURL string
server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
finalURL = r.URL.String()
w.WriteHeader(http.StatusOK)
}))
defer server.Close()
parsed, err := url.Parse(server.URL)
if err != nil {
t.Fatal(err)
}
redirector := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Redirect(w, r, parsed.String(), http.StatusFound)
}))
defer redirector.Close()
client := redirector.Client()
// TLS test servers run on 127.0.0.1, so allow the loopback host in this test only.
sender, err := newWebhookSenderForTest(client, "127.0.0.1")
if err != nil {
t.Fatalf("newWebhookSenderForTest: %v", err)
}
err = sender.SendMarkdown(context.Background(), redirector.URL+"/robot/send", "t", "hello")
if err == nil {
t.Fatalf("expected redirect to be rejected, final request reached %q", finalURL)
}
if !strings.Contains(err.Error(), "redirect") {
t.Fatalf("expected redirect error, got %v", err)
}
}
func TestWebhookSenderRejectsNon2xx(t *testing.T) {
server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusInternalServerError)
}))
defer server.Close()
sender, err := newWebhookSenderForTest(server.Client(), "127.0.0.1")
if err != nil {
t.Fatalf("newWebhookSenderForTest: %v", err)
}
if err := sender.SendMarkdown(context.Background(), server.URL, "t", "hello"); err == nil {
t.Fatal("expected non-2xx error")
}
}
func TestWebhookSenderAcceptsHTTPSDingTalkAndSendsMarkdown(t *testing.T) {
var body []byte
server := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.TLS == nil {
t.Error("request must use TLS")
}
var readErr error
body, readErr = io.ReadAll(r.Body)
if readErr != nil {
t.Errorf("read body: %v", readErr)
}
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
_, _ = w.Write([]byte(`{"errcode":0}`))
}))
server.TLS = &tls.Config{}
server.StartTLS()
defer server.Close()
// Test-only variant that accepts the loopback host but keeps the same
// markdown payload code path as the production oapi.dingtalk.com sender.
sender, err := newWebhookSenderForTest(server.Client(), "127.0.0.1")
if err != nil {
t.Fatalf("newWebhookSenderForTest: %v", err)
}
if err := sender.SendMarkdown(context.Background(), server.URL+"/robot/send?access_token=x", "回答", "**你好**"); err != nil {
t.Fatalf("SendMarkdown: %v", err)
}
var payload struct {
Msgtype string `json:"msgtype"`
Markdown struct {
Title string `json:"title"`
Text string `json:"text"`
} `json:"markdown"`
}
if err := json.Unmarshal(body, &payload); err != nil {
t.Fatalf("payload is not JSON: %v", err)
}
if payload.Msgtype != "markdown" {
t.Fatalf("msgtype = %q, want markdown", payload.Msgtype)
}
if payload.Markdown.Text != "**你好**" || payload.Markdown.Title == "" {
t.Fatalf("unexpected markdown payload: %+v", payload.Markdown)
}
}
func TestWebhookSenderRejectsOversizedResponse(t *testing.T) {
server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
// Stream more than 1MiB so the sender must fail rather than
// silently truncate.
chunk := make([]byte, 64*1024)
for i := 0; i < (maxWebhookBodyBytes/len(chunk))+1; i++ {
_, _ = w.Write(chunk)
}
}))
defer server.Close()
sender, err := newWebhookSenderForTest(server.Client(), "127.0.0.1")
if err != nil {
t.Fatalf("newWebhookSenderForTest: %v", err)
}
err = sender.SendMarkdown(context.Background(), server.URL, "t", "hello")
if err == nil {
t.Fatal("expected error for response body larger than 1MiB, got silent truncation")
}
if !strings.Contains(err.Error(), "exceeds") {
t.Fatalf("expected size-limit error, got %v", err)
}
}
// TestWebhookSenderValidateWebhookURLAcceptsDingTalkHosts asserts the pure
// URL policy accepts oapi.dingtalk.com and *.dingtalk.com over https/443.
func TestWebhookSenderValidateWebhookURLAcceptsDingTalkHosts(t *testing.T) {
for _, raw := range []string{
"https://oapi.dingtalk.com/robot/send?access_token=x",
"https://api.dingtalk.com/v1.0/robot/oToMessages/batchSend",
} {
if err := ValidateWebhookURL(raw); err != nil {
t.Fatalf("ValidateWebhookURL(%q): %v", raw, err)
}
}
}