91 lines
4.7 KiB
Go
91 lines
4.7 KiB
Go
package email
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"io"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strings"
|
|
"testing"
|
|
"unicode/utf8"
|
|
|
|
"git.sendico.io/tech/sxchnge/notifications/model"
|
|
)
|
|
|
|
func TestProviderErrorDiagnostics(t *testing.T) {
|
|
for _, tc := range []struct {
|
|
name, body, code, message string
|
|
}{
|
|
{"resend", `{"name":"validation_error","message":"The sxchnge.com domain is not verified"}`, "validation_error", "The sxchnge.com domain is not verified"},
|
|
{"sendgrid", `{"errors":[{"message":"The sender identity is not verified","field":"from","help":"private URL"}]}`, "", "The sender identity is not verified"},
|
|
{"no message", `{"unrecognized":"private response"}`, "", "Provider did not include an error message"},
|
|
{"malformed", `{"message":"private response"`, "", "Provider error details unavailable: invalid JSON response"},
|
|
{"wrong type", `{"message":{"secret":"private response"}}`, "", "Provider error details unavailable: invalid JSON response"},
|
|
{"trailing", `{"message":"private response"} {}`, "", "Provider error details unavailable: invalid JSON response"},
|
|
{"oversized", `{"message":"` + strings.Repeat("x", maxErrorBody) + `"}`, "", "Provider error details unavailable: incomplete or oversized response"},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
|
|
w.WriteHeader(http.StatusForbidden)
|
|
_, _ = io.WriteString(w, tc.body)
|
|
}))
|
|
defer server.Close()
|
|
c := client{http: server.Client(), endpoint: server.URL}
|
|
out := c.post(context.Background(), "", struct{}{})
|
|
if out.State != model.Failed || out.Code != "provider_authentication_failed" || out.HTTPStatus != 403 || out.ProviderError != tc.code || out.ProviderMessage != tc.message {
|
|
t.Fatalf("unexpected provider outcome: %+v", out)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestProviderDiagnosticsRedactRequestDataBeforeTruncation(t *testing.T) {
|
|
key := "re_credential-secret"
|
|
request := []byte(`{"from":"Sender <sender@example.com>","to":["recipient@example.com"],"personalizations":[{"dynamic_template_data":{"secret":"short-private-value"}}],"subject":"Private subject","text":"Private text","html":"<p>Private HTML</p>","content":[{"value":"Your verification code is 123456; account 9876543210"}]}`)
|
|
token := strings.Repeat("a", 43)
|
|
message := "Credential " + key + "; recipient@example.com; Private subject; Private text; <p>Private HTML</p>; short-private-value; https://example.com/verify?token=" + token + "; " + token + "; 123456; 9876543210; job-secret\n\r\x00\u202eforged-log"
|
|
body, err := json.Marshal(map[string]string{"name": "validation_error", "message": message})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
name, result := providerFailure(body, request, key, "job-secret")
|
|
if name != "validation_error" || !strings.Contains(result, "forged-log") || !strings.Contains(result, "[redacted]") {
|
|
t.Fatal("lost useful diagnostic", name, result)
|
|
}
|
|
for _, forbidden := range []string{key, "recipient@example.com", "Private subject", "Private text", "Private HTML", "short-private-value", "https://", token, "123456", "9876543210", "job-secret", "\n", "\r", "\x00", "\u202e"} {
|
|
if strings.Contains(result, forbidden) {
|
|
t.Fatalf("diagnostic contains sensitive value or control %q", forbidden)
|
|
}
|
|
}
|
|
body, err = json.Marshal(map[string]string{"name": "validation_error", "message": strings.Repeat("ą", maxErrorMessage+20) + key})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
_, result = providerFailure(body, request, key)
|
|
if !utf8.ValidString(result) || utf8.RuneCountInString(result) != maxErrorMessage+1 || !strings.HasSuffix(result, "…") || strings.Contains(result, "re_") {
|
|
t.Fatal("invalid or unbounded diagnostic")
|
|
}
|
|
}
|
|
|
|
func TestSuccessfulResponsesDoNotExposeProviderContent(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
|
|
_, _ = io.WriteString(w, `{"name":"private","message":"private provider response"}`)
|
|
}))
|
|
defer server.Close()
|
|
c := client{http: server.Client(), endpoint: server.URL}
|
|
if out := c.post(context.Background(), "", struct{}{}); out.State != model.Accepted || out.HTTPStatus != 200 || out.ProviderMessage != "" || out.ProviderError != "" {
|
|
t.Fatal("success leaked provider content", out)
|
|
}
|
|
}
|
|
|
|
func TestTransportFailureHasSanitizedDiagnostic(t *testing.T) {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
cancel()
|
|
c := client{http: http.DefaultClient, key: "credential-secret", endpoint: "https://example.com/emails?credential=credential-secret"}
|
|
out := c.post(ctx, "job-secret", struct{}{})
|
|
if out.State != model.Unknown || !strings.Contains(out.ProviderMessage, "context canceled") || strings.Contains(out.ProviderMessage, "credential-secret") || strings.Contains(out.ProviderMessage, "https://") {
|
|
t.Fatal("transport cause missing or unsafe", out)
|
|
}
|
|
}
|