172 lines
5.4 KiB
Go
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)
|
|
}
|
|
}
|
|
}
|