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) } } }