Free, Open Source, Self-Hosted WhatsApp API Gateway
TypeScript apibotgatewayself-hostedwhatsappwhatsapp-apiwhatsapp-automationwhatsapp-botwhatsapp-gatewaywhatsapp-gateway-apiwhatsapp-webwhatsapp-web-api
package openwa
import (
"bytes"
"context"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"net/http/httptest"
"net/url"
"strings"
"sync/atomic"
"testing"
"time"
)
// recordTransport is a mock http.RoundTripper that records the last request and
// replies with a canned response. It is injected via WithTransport — no network,
// no global state.
type recordTransport struct {
status int
body string
header http.Header
lastReq *http.Request
lastRaw []byte
}
func (t *recordTransport) RoundTrip(req *http.Request) (*http.Response, error) {
if err := req.Context().Err(); err != nil {
return nil, err
}
t.lastReq = req
if req.Body != nil {
t.lastRaw, _ = io.ReadAll(req.Body)
}
h := t.header
if h == nil {
h = http.Header{}
}
return &http.Response{
StatusCode: t.status,
Body: io.NopCloser(strings.NewReader(t.body)),
Header: h,
Request: req,
}, nil
}
func newTestClient(t *testing.T, rt http.RoundTripper, opts ...Option) *Client {
t.Helper()
all := append([]Option{WithTransport(rt)}, opts...)
c, err := New("https://api.example.com", "owa_k1_test", all...)
if err != nil {
t.Fatalf("New: %v", err)
}
return c
}
func TestNewValidation(t *testing.T) {
if _, err := New("", "key"); err == nil {
t.Fatal("expected error for empty baseURL")
}
if _, err := New("https://x", ""); err == nil {
t.Fatal("expected error for empty apiKey")
}
}
func TestNewTrimsTheKeyAndRefusesAControlCharacterWithoutRepeatingIt(t *testing.T) {
rt := &recordTransport{status: 200, body: `{"valid":true}`}
c, err := New("https://x", " owa_k1_test\n", WithTransport(rt))
if err != nil {
t.Fatalf("New: %v", err)
}
if _, err := c.Auth.Validate(context.Background()); err != nil {
t.Fatalf("Validate: %v", err)
}
if got := rt.lastReq.Header.Get("X-API-Key"); got != "owa_k1_test" {
t.Fatalf("X-API-Key = %q, want the trimmed key", got)
}
// An inner space is part of a passphrase key.
if _, err := New("https://x", "correct horse battery"); err != nil {
t.Fatalf("a key with an inner space: %v", err)
}
for _, bad := range []string{"owa_k1_se\ncret", "owa_k1_se\x00cret", "owa_k1_se\x7fcret"} {
_, err := New("https://x", bad)
if err == nil {
t.Fatalf("expected an error for %q", bad)
}
if strings.Contains(err.Error(), "cret") {
t.Fatalf("the error repeats the key: %v", err)
}
}
}
func TestSendTextHitsCorrectPath(t *testing.T) {
rt := &recordTransport{status: 200, body: `{"messageId":"m1","timestamp":123}`}
c := newTestClient(t, rt)
res, err := c.Messages.SendText(context.Background(), "s1", SendTextRequest{
ChatID: "[email protected]",
Text: "hi",
})
if err != nil {
t.Fatalf("SendText: %v", err)
}
if res.MessageID != "m1" || res.Timestamp != 123 {
t.Fatalf("unexpected response: %+v", res)
}
// The historically-broken path was /messages/text; the real one is send-text.
wantPath := "/api/sessions/s1/messages/send-text"
if got := rt.lastReq.URL.Path; got != wantPath {
t.Fatalf("path = %q, want %q", got, wantPath)
}
if rt.lastReq.Method != "POST" {
t.Fatalf("method = %q, want POST", rt.lastReq.Method)
}
if got := rt.lastReq.Header.Get("X-API-Key"); got != "owa_k1_test" {
t.Fatalf("X-API-Key = %q", got)
}
var sent SendTextRequest
if err := json.Unmarshal(rt.lastRaw, &sent); err != nil {
t.Fatalf("body not JSON: %v", err)
}
if sent.ChatID != "[email protected]" || sent.Text != "hi" {
t.Fatalf("sent body = %+v", sent)
}
}
func TestJIDPathIsReadable(t *testing.T) {
rt := &recordTransport{status: 200, body: `{}`}
c := newTestClient(t, rt)
_, _ = c.Contacts.Check(context.Background(), "s1", "[email protected]")
// @ stays readable, not percent-encoded.
want := "/api/sessions/s1/contacts/check/[email protected]"
if got := rt.lastReq.URL.EscapedPath(); got != want {
t.Fatalf("escaped path = %q, want %q", got, want)
}
}
func TestEmptyAndDotSegmentsRefused(t *testing.T) {
var hits int32
rt := RoundTripperFunc(func(req *http.Request) (*http.Response, error) {
atomic.AddInt32(&hits, 1)
return &http.Response{StatusCode: 204, Body: io.NopCloser(strings.NewReader("")), Header: http.Header{}, Request: req}, nil
})
c := newTestClient(t, rt)
ctx := context.Background()
refused := map[string]error{
`Webhooks.Delete ".."`: c.Webhooks.Delete(ctx, "s1", ".."),
`Webhooks.Delete "."`: c.Webhooks.Delete(ctx, "s1", "."),
`Webhooks.Delete ""`: c.Webhooks.Delete(ctx, "s1", ""),
`Do %2E%2e`: c.Do(ctx, "DELETE", "/api/sessions/s1/labels/%2E%2e", nil, nil, nil),
`Do ..`: c.Do(ctx, "GET", "/api/sessions/s1/..?x=1", nil, nil, nil),
}
_, err := c.Sessions.Get(ctx, "")
refused[`Sessions.Get ""`] = err
_, err = c.Messages.Media(ctx, "s1", "..", "m1")
refused[`Messages.Media ".."`] = err
_, err = c.Status.Media(ctx, "s1", ".")
refused[`Status.Media "."`] = err
for name, err := range refused {
if err == nil || !strings.Contains(err.Error(), "path segment") {
t.Errorf("%s: err = %v, want a path segment error", name, err)
}
}
if n := atomic.LoadInt32(&hits); n != 0 {
t.Fatalf("%d requests sent, want 0", n)
}
// Dots inside an id, a dot-only query value, and a hand-written trailing or
// double slash are not refused.
for _, id := range []string{"a.b", "...", "[email protected]"} {
if err := c.Webhooks.Delete(ctx, "s1", id); err != nil {
t.Errorf("Webhooks.Delete %q: %v", id, err)
}
}
for _, path := range []string{"/api/sessions/", "/api/sessions//x", "/", "/api/labels/a.b?x=/.."} {
if err := c.Do(ctx, "GET", path, nil, nil, nil); err != nil {
t.Errorf("Do %q: %v", path, err)
}
}
if n := atomic.LoadInt32(&hits); n != 7 {
t.Fatalf("%d requests sent, want 7", n)
}
}
func TestListSessionsQueryName(t *testing.T) {
rt := &recordTransport{status: 200, body: `[]`}
c := newTestClient(t, rt)
if _, err := c.Sessions.List(context.Background(), &ListSessionsQuery{Name: Ptr("my-bot")}); err != nil {
t.Fatalf("List: %v", err)
}
if got := rt.lastReq.URL.RawQuery; got != "name=my-bot" {
t.Fatalf("query = %q, want %q", got, "name=my-bot")
}
}
func TestQueryEncoding(t *testing.T) {
rt := &recordTransport{status: 200, body: `{"messages":[],"total":0,"unknownTimestampTotal":2}`}
c := newTestClient(t, rt)
page, err := c.Messages.List(context.Background(), "s1", &ListMessagesQuery{
ChatID: Ptr("[email protected]"),
Limit: Ptr(10),
Since: Ptr(1789855200000.5), Until: Ptr(1789941600000.0),
Direction: Ptr("incoming"), OrderBy: Ptr("timestamp"), Type: Ptr("image"), MessageID: Ptr("M1"),
})
if err != nil {
t.Fatalf("List: %v", err)
}
q := rt.lastReq.URL.Query()
if q.Get("chatId") != "[email protected]" || q.Get("limit") != "10" {
t.Fatalf("query = %v", rt.lastReq.URL.RawQuery)
}
if _, ok := q["offset"]; ok {
t.Fatal("nil offset should not appear in query")
}
for key, expected := range map[string]string{"since": "1789855200000.5", "until": "1789941600000", "direction": "incoming", "orderBy": "timestamp", "type": "image", "messageId": "M1"} {
if q.Get(key) != expected {
t.Fatalf("%s = %q, want %q", key, q.Get(key), expected)
}
}
if page.UnknownTimestampTotal == nil || *page.UnknownTimestampTotal != 2 {
t.Fatalf("unknown time count = %v", page.UnknownTimestampTotal)
}
}
func TestNilQueryOmitted(t *testing.T) {
rt := &recordTransport{status: 200, body: `[]`}
c := newTestClient(t, rt)
// Typed-nil pointer must not panic and must send no query string.
var q *ListContactsQuery
if _, err := c.Contacts.List(context.Background(), "s1", q); err != nil {
t.Fatalf("List: %v", err)
}
if rt.lastReq.URL.RawQuery != "" {
t.Fatalf("expected empty query, got %q", rt.lastReq.URL.RawQuery)
}
}
func TestTypedErrors(t *testing.T) {
rt := &recordTransport{
status: 409,
body: `{"statusCode":409,"message":"engine not ready","error":"Conflict"}`,
}
c := newTestClient(t, rt)
_, err := c.Messages.SendText(context.Background(), "s1", SendTextRequest{ChatID: "x", Text: "y"})
if err == nil {
t.Fatal("expected error")
}
if !errors.Is(err, ErrConflict) {
t.Fatalf("errors.Is ErrConflict = false for %v", err)
}
var apiErr *APIError
if !errors.As(err, &apiErr) {
t.Fatalf("errors.As *APIError failed for %v", err)
}
if apiErr.StatusCode != 409 || apiErr.Kind != "Conflict" || apiErr.Message != "engine not ready" {
t.Fatalf("APIError = %+v", apiErr)
}
}
func TestAPIErrorCodeRetryAfterAndHeader(t *testing.T) {
fail := func(status int, body string, header http.Header) *APIError {
t.Helper()
c := newTestClient(t, &recordTransport{status: status, body: body, header: header})
_, err := c.Sessions.List(context.Background(), nil)
var apiErr *APIError
if !errors.As(err, &apiErr) {
t.Fatalf("errors.As *APIError failed for %v", err)
}
return apiErr
}
throttled := fail(429, `{"statusCode":429,"message":"ThrottlerException: Too Many Requests"}`, http.Header{"Retry-After": {"7"}})
if !errors.Is(throttled, ErrRateLimited) || throttled.RetryAfter != 7*time.Second || throttled.Code != "" {
t.Fatalf("throttled = %+v", throttled)
}
if throttled.Header.Get("Retry-After") != "7" {
t.Fatalf("Header = %v", throttled.Header)
}
// Send pacing puts its wait in the body; a header must not shorten it.
pacing := `{"statusCode":429,"error":"Too Many Requests","message":"Daily send cap reached","code":"SEND_PACING_LIMITED","retryAfterSeconds":34521}`
for _, h := range []http.Header{nil, {"Retry-After": {"1"}}} {
e := fail(429, pacing, h)
if e.Code != "SEND_PACING_LIMITED" || e.RetryAfter != 34521*time.Second {
t.Fatalf("pacing with header %v = %+v", h, e)
}
}
dated := fail(503, "", http.Header{"Retry-After": {time.Now().Add(2 * time.Second).UTC().Format(http.TimeFormat)}})
if dated.RetryAfter <= 0 || dated.RetryAfter > 3*time.Second {
t.Fatalf("HTTP-date RetryAfter = %v", dated.RetryAfter)
}
for _, v := range []string{"soon", "-5"} {
if e := fail(503, "", http.Header{"Retry-After": {v}}); e.RetryAfter != 0 {
t.Fatalf("Retry-After %q gave %v", v, e.RetryAfter)
}
}
if e := fail(502, `{"statusCode":502,"message":"x","code":"SESSION_LOGOUT_INCOMPLETE"}`, nil); e.Code != "SESSION_LOGOUT_INCOMPLETE" {
t.Fatalf("Code = %q", e.Code)
}
if e := fail(500, "oops", nil); e.Code != "" || e.RetryAfter != 0 {
t.Fatalf("plain-text error = %+v", e)
}
}
func TestArrayMessageError(t *testing.T) {
rt := &recordTransport{
status: 400,
body: `{"statusCode":400,"message":["chatId must be a string","text should not be empty"],"error":"Bad Request"}`,
}
c := newTestClient(t, rt)
_, err := c.Messages.SendText(context.Background(), "s1", SendTextRequest{})
var apiErr *APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expected APIError, got %v", err)
}
if !strings.Contains(apiErr.Message, "chatId must be a string, text should not be empty") {
t.Fatalf("message = %q", apiErr.Message)
}
}
func TestRedirectNotFollowed(t *testing.T) {
rt := &recordTransport{status: 302, body: "", header: http.Header{"Location": {"https://evil.example"}}}
c := newTestClient(t, rt)
_, err := c.Sessions.List(context.Background(), nil)
var apiErr *APIError
if !errors.As(err, &apiErr) || apiErr.StatusCode != 302 {
t.Fatalf("expected 302 APIError, got %v", err)
}
}
func TestDeleteReturnsNoBody(t *testing.T) {
rt := &recordTransport{status: 204, body: ""}
c := newTestClient(t, rt)
if err := c.Sessions.Delete(context.Background(), "s1"); err != nil {
t.Fatalf("Delete: %v", err)
}
if rt.lastReq.Method != "DELETE" {
t.Fatalf("method = %q", rt.lastReq.Method)
}
}
// retryTransport fails the first N calls with a 503, then succeeds. It rewinds
// and asserts the body is present on every attempt.
type retryTransport struct {
failuresLeft int32
calls int32
gotBodies []string
}
func (t *retryTransport) RoundTrip(req *http.Request) (*http.Response, error) {
atomic.AddInt32(&t.calls, 1)
var b []byte
if req.Body != nil {
b, _ = io.ReadAll(req.Body)
}
t.gotBodies = append(t.gotBodies, string(b))
if atomic.AddInt32(&t.failuresLeft, -1) >= 0 {
return &http.Response{StatusCode: 503, Body: io.NopCloser(bytes.NewReader(nil)), Header: http.Header{}, Request: req}, nil
}
return &http.Response{StatusCode: 200, Body: io.NopCloser(strings.NewReader(`{"messageId":"ok","timestamp":1}`)), Header: http.Header{}, Request: req}, nil
}
func TestRetryPolicy(t *testing.T) {
rt := &retryTransport{failuresLeft: 2}
c := newTestClient(t, rt, WithRetry(RetryPolicy{
MaxRetries: 3,
BaseDelay: time.Millisecond,
MaxDelay: 5 * time.Millisecond,
}))
res, err := c.Messages.SendText(context.Background(), "s1", SendTextRequest{ChatID: "x", Text: "y"})
if err != nil {
t.Fatalf("SendText with retry: %v", err)
}
if res.MessageID != "ok" {
t.Fatalf("res = %+v", res)
}
if rt.calls != 3 {
t.Fatalf("expected 3 attempts, got %d", rt.calls)
}
// Body must be re-sent (rewound) on every attempt.
for i, b := range rt.gotBodies {
if !strings.Contains(b, `"chatId":"x"`) {
t.Fatalf("attempt %d had empty/rewound-broken body: %q", i, b)
}
}
}
// statusTransport always replies with the same status, counting attempts.
type statusTransport struct {
status int
calls int32
}
func (t *statusTransport) RoundTrip(req *http.Request) (*http.Response, error) {
atomic.AddInt32(&t.calls, 1)
if req.Body != nil {
io.Copy(io.Discard, req.Body)
}
return &http.Response{
StatusCode: t.status,
Body: io.NopCloser(strings.NewReader(`{"statusCode":500,"message":"boom","error":"Internal"}`)),
Header: http.Header{},
Request: req,
}, nil
}
// A 500/502/504 can be returned after the gateway already sent the message, so
// replaying a POST on those would double-send. Only 429/503 — which prove the
// server declined before acting — may retry a non-idempotent request.
func TestRetryDoesNotReplayPostOnAmbiguousStatus(t *testing.T) {
for _, status := range []int{500, 502, 504} {
t.Run(http.StatusText(status), func(t *testing.T) {
rt := &statusTransport{status: status}
c := newTestClient(t, rt, WithRetry(RetryPolicy{
MaxRetries: 3, BaseDelay: time.Millisecond, MaxDelay: 5 * time.Millisecond,
RetryableStatuses: []int{429, 500, 502, 503, 504},
}))
_, err := c.Messages.SendText(context.Background(), "s1", SendTextRequest{ChatID: "x", Text: "y"})
if err == nil {
t.Fatal("expected an error")
}
if rt.calls != 1 {
t.Fatalf("POST on %d must not be replayed: got %d attempts, want 1", status, rt.calls)
}
})
}
}
// The same statuses ARE retried for an idempotent method — the conservative
// rule must not blunt retries where replay is safe.
func TestRetryStillReplaysIdempotentOnAmbiguousStatus(t *testing.T) {
rt := &statusTransport{status: 500}
c := newTestClient(t, rt, WithRetry(RetryPolicy{
MaxRetries: 2, BaseDelay: time.Millisecond, MaxDelay: 5 * time.Millisecond,
RetryableStatuses: []int{429, 500, 502, 503, 504},
}))
_, err := c.Sessions.List(context.Background(), nil)
if err == nil {
t.Fatal("expected an error")
}
if rt.calls != 3 {
t.Fatalf("GET on 500 should retry: got %d attempts, want 3", rt.calls)
}
}
// 429/503 mean the server declined before acting, so a POST may still retry.
func TestRetryReplaysPostOnBackpressure(t *testing.T) {
for _, status := range []int{429, 503} {
t.Run(http.StatusText(status), func(t *testing.T) {
rt := &statusTransport{status: status}
c := newTestClient(t, rt, WithRetry(RetryPolicy{
MaxRetries: 2, BaseDelay: time.Millisecond, MaxDelay: 5 * time.Millisecond,
RetryableStatuses: []int{429, 500, 502, 503, 504},
}))
_, err := c.Messages.SendText(context.Background(), "s1", SendTextRequest{ChatID: "x", Text: "y"})
if err == nil {
t.Fatal("expected an error")
}
if rt.calls != 3 {
t.Fatalf("POST on %d is backpressure and should retry: got %d attempts, want 3", status, rt.calls)
}
})
}
}
// pacingTransport replies with the gateway's send-pacing refusal: a 429 with no
// Retry-After whose body carries the real delay, which can be hours.
type pacingTransport struct{ calls int32 }
func (t *pacingTransport) RoundTrip(req *http.Request) (*http.Response, error) {
atomic.AddInt32(&t.calls, 1)
if req.Body != nil {
_, _ = io.Copy(io.Discard, req.Body)
}
return &http.Response{
StatusCode: 429,
Body: io.NopCloser(strings.NewReader(
`{"statusCode":429,"message":"Daily send cap reached","code":"SEND_PACING_LIMITED","retryAfterSeconds":34521}`)),
Header: http.Header{},
Request: req,
}, nil
}
// A send-pacing refusal must not be retried before retryAfterSeconds, so the
// policy returns it after one attempt, with the body intact for the caller.
func TestRetryDoesNotReplaySendPacingRefusal(t *testing.T) {
rt := &pacingTransport{}
c := newTestClient(t, rt, WithRetry(RetryPolicy{
MaxRetries: 3, BaseDelay: time.Millisecond, MaxDelay: 5 * time.Millisecond,
RetryableStatuses: []int{429, 500, 502, 503, 504}, RespectRetryAfter: true,
}))
_, err := c.Messages.SendText(context.Background(), "s1", SendTextRequest{ChatID: "x", Text: "y"})
var apiErr *APIError
if !errors.As(err, &apiErr) || !errors.Is(err, ErrRateLimited) {
t.Fatalf("expected a 429 APIError, got %v", err)
}
if rt.calls != 1 {
t.Fatalf("a SEND_PACING_LIMITED 429 must not be retried: got %d attempts, want 1", rt.calls)
}
body, _ := apiErr.Body.(map[string]any)
if body["code"] != "SEND_PACING_LIMITED" || body["retryAfterSeconds"] != float64(34521) {
t.Fatalf("expected the refusal body to reach the caller, got %#v", apiErr.Body)
}
}
func TestMiddlewarePipeline(t *testing.T) {
rt := &recordTransport{status: 200, body: `[]`}
var hits int32
mw := func(next http.RoundTripper) http.RoundTripper {
return RoundTripperFunc(func(req *http.Request) (*http.Response, error) {
atomic.AddInt32(&hits, 1)
req.Header.Set("X-Trace", "on")
return next.RoundTrip(req)
})
}
c := newTestClient(t, rt, WithMiddleware(mw))
if _, err := c.Sessions.List(context.Background(), nil); err != nil {
t.Fatalf("List: %v", err)
}
if hits != 1 {
t.Fatalf("middleware hits = %d, want 1", hits)
}
if rt.lastReq.Header.Get("X-Trace") != "on" {
t.Fatal("middleware header not propagated")
}
}
// retryAfterTransport replies once with 429 + Retry-After, then success. It
// records the delay between the two calls so a test can assert Retry-After was
// honored.
type retryAfterTransport struct {
calls int32
stamps []time.Time
header string
}
func (t *retryAfterTransport) RoundTrip(req *http.Request) (*http.Response, error) {
atomic.AddInt32(&t.calls, 1)
t.stamps = append(t.stamps, time.Now())
if req.Body != nil {
_, _ = io.ReadAll(req.Body)
}
if t.calls == 1 {
return &http.Response{
StatusCode: 429,
Body: io.NopCloser(strings.NewReader("")),
Header: http.Header{"Retry-After": {t.header}},
Request: req,
}, nil
}
return &http.Response{
StatusCode: 200,
Body: io.NopCloser(strings.NewReader(`{"messageId":"ok","timestamp":1}`)),
Header: http.Header{},
Request: req,
}, nil
}
func TestRetryHonorsRetryAfter(t *testing.T) {
rt := &retryAfterTransport{header: "1"}
c := newTestClient(t, rt, WithRetry(RetryPolicy{
MaxRetries: 2,
BaseDelay: time.Millisecond, // computed backoff = 1ms; Retry-After = 1s dominates
MaxDelay: 10 * time.Millisecond,
RetryableStatuses: []int{429},
RespectRetryAfter: true,
}))
if _, err := c.Messages.SendText(context.Background(), "s1", SendTextRequest{ChatID: "x", Text: "y"}); err != nil {
t.Fatalf("SendText: %v", err)
}
if rt.calls != 2 {
t.Fatalf("expected 2 attempts, got %d", rt.calls)
}
waited := rt.stamps[1].Sub(rt.stamps[0])
if waited < 900*time.Millisecond {
t.Fatalf("expected to wait ~1s for Retry-After, waited %s", waited)
}
}
// A Retry-After longer than the time left on the request cannot be honored, so
// the 429 goes back to the caller at once instead of sleeping out the timeout
// and surfacing as a *TimeoutError that hides the rate limit.
func TestRetryReturnsResponseWhenRetryAfterOutlastsDeadline(t *testing.T) {
rt := &retryAfterTransport{header: "60"}
c := newTestClient(t, rt, WithTimeout(500*time.Millisecond), WithRetry(DefaultRetryPolicy()))
start := time.Now()
_, err := c.Messages.SendText(context.Background(), "s1", SendTextRequest{ChatID: "x", Text: "y"})
if !errors.Is(err, ErrRateLimited) {
t.Fatalf("expected ErrRateLimited, got %v", err)
}
if elapsed := time.Since(start); elapsed > 250*time.Millisecond {
t.Fatalf("expected the 429 back at once, waited %s", elapsed)
}
if rt.calls != 1 {
t.Fatalf("expected 1 attempt, got %d", rt.calls)
}
}
func TestParseRetryAfterHTTPDate(t *testing.T) {
resp := &http.Response{Header: http.Header{"Retry-After": {time.Now().Add(2 * time.Second).UTC().Format(http.TimeFormat)}}}
d, ok := parseRetryAfter(resp)
if !ok {
t.Fatal("expected HTTP-date Retry-After to parse")
}
if d < time.Second || d > 3*time.Second {
t.Fatalf("unexpected duration: %s", d)
}
}
// networkErrTransport always returns a network error, so it exercises the
// "retry on network error" branch instead of the "retry on status code" branch.
type networkErrTransport struct{ calls int32 }
func (t *networkErrTransport) RoundTrip(req *http.Request) (*http.Response, error) {
atomic.AddInt32(&t.calls, 1)
return nil, errors.New("simulated network failure")
}
func TestRetrySkipsNonIdempotentOnNetworkError(t *testing.T) {
rt := &networkErrTransport{}
c := newTestClient(t, rt, WithRetry(RetryPolicy{
MaxRetries: 3,
BaseDelay: time.Millisecond,
MaxDelay: time.Millisecond,
}))
// POST is not idempotent: a network error must NOT retry, or a message
// could be double-sent.
_, err := c.Messages.SendText(context.Background(), "s1", SendTextRequest{ChatID: "x", Text: "y"})
if err == nil {
t.Fatal("expected error")
}
if rt.calls != 1 {
t.Fatalf("expected 1 attempt for POST on network error, got %d", rt.calls)
}
}
func TestRetryIdempotentOnNetworkError(t *testing.T) {
rt := &networkErrTransport{}
c := newTestClient(t, rt, WithRetry(RetryPolicy{
MaxRetries: 2,
BaseDelay: time.Millisecond,
MaxDelay: time.Millisecond,
}))
// GET is idempotent: a network error is safe to retry.
_, err := c.Sessions.List(context.Background(), nil)
if err == nil {
t.Fatal("expected error")
}
if rt.calls != 3 {
t.Fatalf("expected 3 attempts (1 + 2 retries) for GET on network error, got %d", rt.calls)
}
}
func TestBadRequestSentinel(t *testing.T) {
rt := &recordTransport{
status: 400,
body: `{"statusCode":400,"message":"invalid","error":"Bad Request"}`,
}
c := newTestClient(t, rt)
_, err := c.Messages.SendText(context.Background(), "s1", SendTextRequest{})
if err == nil {
t.Fatal("expected error")
}
if !errors.Is(err, ErrBadRequest) {
t.Fatalf("errors.Is ErrBadRequest = false for %v", err)
}
}
func TestStatusListEnvelope(t *testing.T) {
rt := &recordTransport{
status: 200,
body: `{"statuses":[{"id":"s","contact":{"id":"[email protected]","name":"Cat"},"type":"text","mediaUrl":"","caption":"hi"}]}`,
}
c := newTestClient(t, rt)
got, err := c.Status.List(context.Background(), "s1")
if err != nil {
t.Fatalf("Status.List: %v", err)
}
if len(got) != 1 || got[0].ID != "s" || got[0].Contact.Name != "Cat" {
t.Fatalf("unexpected decode: %+v", got)
}
}
func TestHealthReadyDependencyDecode(t *testing.T) {
rt := &recordTransport{
status: 200,
body: `{"status":"ok","details":{"mainDatabase":{"status":"up"},"dataDatabase":{"status":"up"}}}`,
}
c := newTestClient(t, rt)
res, err := c.Health.Ready(context.Background())
if err != nil {
t.Fatalf("Health.Ready: %v", err)
}
if res.Details["mainDatabase"].Status != "up" || res.Details["dataDatabase"].Status != "up" {
t.Fatalf("unexpected details: %+v", res.Details)
}
}
func TestWithHeaderMultiValue(t *testing.T) {
rt := &recordTransport{status: 200, body: `[]`}
c := newTestClient(t, rt,
WithHeader("X-Trace", "a"),
WithHeader("X-Trace", "b"),
)
if _, err := c.Sessions.List(context.Background(), nil); err != nil {
t.Fatalf("List: %v", err)
}
got := rt.lastReq.Header.Values("X-Trace")
if len(got) != 2 || got[0] != "a" || got[1] != "b" {
t.Fatalf("X-Trace values = %v, want [a b]", got)
}
}
func TestWithTimeoutZeroUsesDefault(t *testing.T) {
rt := &recordTransport{status: 200, body: `[]`}
c := newTestClient(t, rt, WithTimeout(0))
if c.timeout != DefaultTimeout {
t.Fatalf("timeout = %s, want %s", c.timeout, DefaultTimeout)
}
}
func TestInjectedHTTPClientTimeoutIsHonoredUnlessWithTimeoutIsExplicit(t *testing.T) {
injected := &http.Client{Timeout: 45 * time.Second}
c, err := New("http://localhost:2785", "k", WithHTTPClient(injected))
if err != nil {
t.Fatalf("New: %v", err)
}
if c.timeout != 45*time.Second {
t.Fatalf("injected timeout = %s, want 45s", c.timeout)
}
c, err = New("http://localhost:2785", "k", WithHTTPClient(injected), WithTimeout(5*time.Second))
if err != nil {
t.Fatalf("New explicit: %v", err)
}
if c.timeout != 5*time.Second {
t.Fatalf("explicit timeout = %s, want 5s", c.timeout)
}
}
func TestBulkMediaContentOmitsChatID(t *testing.T) {
// The bulk media block must not emit a chatId key — the outer item carries
// it, and BulkMediaDto rejects a stray empty one via forbidNonWhitelisted.
body := SendBulkRequest{
Messages: []BulkMessageItem{{
ChatID: "[email protected]",
Type: "image",
Content: BulkMessageContent{
Image: &BulkMediaContent{URL: "https://x/y.png"},
},
}},
}
raw, err := json.Marshal(body)
if err != nil {
t.Fatalf("marshal: %v", err)
}
if strings.Contains(string(raw), `"chatId":""`) {
t.Fatalf("bulk media block must not emit empty chatId; got: %s", raw)
}
}
func TestBulkAudioSerializesPTT(t *testing.T) {
// Bulk audio with PTT must emit "ptt":true so the server sends it as a voice
// note; the media block must not emit a "caption" key (not whitelisted by
// BulkMediaDto — caption lives at the content level).
body := SendBulkRequest{
Messages: []BulkMessageItem{{
ChatID: "[email protected]",
Type: "audio",
Content: BulkMessageContent{
Audio: &BulkMediaContent{URL: "https://x/v.ogg", PTT: true},
Caption: "voicenote",
},
}},
}
raw, err := json.Marshal(body)
if err != nil {
t.Fatalf("marshal: %v", err)
}
if !strings.Contains(string(raw), `"ptt":true`) {
t.Fatalf("bulk audio must emit ptt:true; got: %s", raw)
}
audioBlock := string(raw)
if i := strings.Index(audioBlock, `"audio":{`); i >= 0 {
if j := strings.Index(audioBlock[i:], "}"); j >= 0 && strings.Contains(audioBlock[i:i+j], `"caption"`) {
t.Fatalf("bulk media block must not emit caption; got: %s", raw)
}
}
}
// capturingLogger records what the SDK logs.
type capturingLogger struct{ msgs []string }
func (l *capturingLogger) Log(_ context.Context, _ string, msg string, _ ...any) {
l.msgs = append(l.msgs, msg)
}
// The insecure-http warning must reach an injected logger...
func TestInsecureHTTPWarnsInjectedLogger(t *testing.T) {
lg := &capturingLogger{}
if _, err := New("http://wa.example.com:2785", "k", WithLogger(lg)); err != nil {
t.Fatalf("New: %v", err)
}
if len(lg.msgs) != 1 || !strings.Contains(lg.msgs[0], "insecure http://") {
t.Fatalf("expected an insecure-http warning, got %v", lg.msgs)
}
}
// ...and must stay silent for https, localhost, or when explicitly suppressed.
func TestInsecureHTTPWarningSuppressed(t *testing.T) {
cases := []struct {
name string
url string
opts []Option
}{
{"https", "https://wa.example.com", nil},
{"localhost", "http://localhost:2785", nil},
{"loopback ip", "http://127.0.0.1:2785", nil},
{"explicitly allowed", "http://wa.example.com", []Option{WithInsecureHTTP()}},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
lg := &capturingLogger{}
if _, err := New(tc.url, "k", append([]Option{WithLogger(lg)}, tc.opts...)...); err != nil {
t.Fatalf("New: %v", err)
}
if len(lg.msgs) != 0 {
t.Fatalf("expected no warning, got %v", lg.msgs)
}
})
}
}
// The server types status timestamps as Date, which serializes to RFC 3339.
func TestStatusTimestampsDecodeRFC3339(t *testing.T) {
rt := &recordTransport{status: 200, body: `{"statuses":[{"id":"s1","contact":{"id":"[email protected]"},"timestamp":"2026-07-17T10:30:00.000Z","expiresAt":"2026-07-18T10:30:00.000Z"}]}`}
c := newTestClient(t, rt)
out, err := c.Status.List(context.Background(), "s1")
if err != nil {
t.Fatalf("Status.List: %v", err)
}
if len(out) != 1 {
t.Fatalf("want 1 status, got %d", len(out))
}
got := out[0]
if want := time.Date(2026, 7, 17, 10, 30, 0, 0, time.UTC); !got.Timestamp.Equal(want) {
t.Fatalf("Timestamp = %v, want %v", got.Timestamp, want)
}
if want := time.Date(2026, 7, 18, 10, 30, 0, 0, time.UTC); !got.ExpiresAt.Equal(want) {
t.Fatalf("ExpiresAt = %v, want %v", got.ExpiresAt, want)
}
}
func TestContextCancel(t *testing.T) {
rt := &recordTransport{status: 200, body: `[]`}
c := newTestClient(t, rt)
ctx, cancel := context.WithCancel(context.Background())
cancel()
_, err := c.Sessions.List(ctx, nil)
if err == nil {
t.Fatal("expected context cancellation error")
}
}
// The channel routes return the engine-neutral Channel verbatim (no DTO), so the record must carry
// inviteCode/picture/verified/createdAt and must not invent pictureUrl/role (#754).
func TestChannelListDecodesWireShape(t *testing.T) {
rt := &recordTransport{
status: 200,
body: `[{"id":"123@newsletter","name":"News","description":"d","inviteCode":"abc123",` +
`"subscriberCount":7,"picture":"https://x/p.jpg","verified":true,"createdAt":1700000000}]`,
}
c := newTestClient(t, rt)
got, err := c.Channels.List(context.Background(), "s1")
if err != nil {
t.Fatalf("Channels.List: %v", err)
}
if len(got) != 1 {
t.Fatalf("want 1 channel, got %d", len(got))
}
ch := got[0]
if ch.InviteCode == nil || *ch.InviteCode != "abc123" {
t.Errorf("InviteCode: %+v", ch.InviteCode)
}
if ch.Picture == nil || *ch.Picture != "https://x/p.jpg" {
t.Errorf("Picture: %+v", ch.Picture)
}
if ch.Verified == nil || !*ch.Verified {
t.Errorf("Verified: %+v", ch.Verified)
}
if ch.CreatedAt == nil || *ch.CreatedAt != 1700000000 {
t.Errorf("CreatedAt: %+v", ch.CreatedAt)
}
}
// Channel messages are the live engine payload, not the persisted MessageRecord (#754).
func TestChannelMessagesDecodeEngineShape(t *testing.T) {
rt := &recordTransport{
status: 200,
body: `[{"id":"m1","body":"hi","timestamp":1700000000,"hasMedia":true,"mediaUrl":"https://x/m.jpg"}]`,
}
c := newTestClient(t, rt)
got, err := c.Channels.Messages(context.Background(), "s1", "123@newsletter", nil)
if err != nil {
t.Fatalf("Channels.Messages: %v", err)
}
if len(got) != 1 {
t.Fatalf("want 1 message, got %d", len(got))
}
msg := got[0]
if msg.ID != "m1" || msg.Body != "hi" || msg.Timestamp != 1700000000 {
t.Errorf("scalar decode: %+v", msg)
}
if !msg.HasMedia {
t.Errorf("HasMedia: %+v", msg.HasMedia)
}
if msg.MediaURL != "https://x/m.jpg" {
t.Errorf("MediaURL: %q", msg.MediaURL)
}
}
func TestEditMessage(t *testing.T) {
rt := &recordTransport{status: 200, body: `{"messageId":"m1","timestamp":1700000001}`}
c := newTestClient(t, rt)
res, err := c.Messages.EditMessage(context.Background(), "s1", EditMessageRequest{
ChatID: "[email protected]",
MessageID: "m1",
Body: "edited",
})
if err != nil {
t.Fatalf("EditMessage: %v", err)
}
if res.MessageID != "m1" || res.Timestamp != 1700000001 {
t.Fatalf("unexpected response: %+v", res)
}
wantPath := "/api/sessions/s1/messages/edit"
if got := rt.lastReq.URL.Path; got != wantPath {
t.Fatalf("path = %q, want %q", got, wantPath)
}
if rt.lastReq.Method != "POST" {
t.Fatalf("method = %q, want POST", rt.lastReq.Method)
}
var sent EditMessageRequest
if err := json.Unmarshal(rt.lastRaw, &sent); err != nil {
t.Fatalf("body not JSON: %v", err)
}
if sent.ChatID != "[email protected]" || sent.MessageID != "m1" || sent.Body != "edited" {
t.Fatalf("sent body = %+v", sent)
}
}
func TestEditMessageNotFound(t *testing.T) {
rt := &recordTransport{
status: 404,
body: `{"statusCode":404,"message":"Message not found","error":"Not Found"}`,
}
c := newTestClient(t, rt)
_, err := c.Messages.EditMessage(context.Background(), "s1", EditMessageRequest{
ChatID: "x", MessageID: "nope", Body: "y",
})
if !errors.Is(err, ErrNotFound) {
t.Fatalf("errors.Is ErrNotFound = false for %v", err)
}
}
func TestJoinGroup(t *testing.T) {
rt := &recordTransport{status: 200, body: `{"success":true,"groupId":"[email protected]"}`}
c := newTestClient(t, rt)
res, err := c.Groups.JoinGroup(context.Background(), "s1", JoinGroupRequest{InviteCode: "abc123"})
if err != nil {
t.Fatalf("JoinGroup: %v", err)
}
if !res.Success || res.GroupID != "[email protected]" {
t.Fatalf("unexpected response: %+v", res)
}
var sent JoinGroupRequest
if err := json.Unmarshal(rt.lastRaw, &sent); err != nil {
t.Fatalf("body not JSON: %v", err)
}
if sent.InviteCode != "abc123" {
t.Fatalf("sent body = %+v", sent)
}
}
func TestGetGroupSettings(t *testing.T) {
// ephemeralSeconds is absent when the engine does not report it — it must
// decode as nil, not as a zero-valued present field.
rt := &recordTransport{status: 200, body: `{"announce":true,"locked":false}`}
c := newTestClient(t, rt)
got, err := c.Groups.GetGroupSettings(context.Background(), "s1", "g1")
if err != nil {
t.Fatalf("GetGroupSettings: %v", err)
}
if got.Announce == nil || !*got.Announce {
t.Errorf("Announce: %+v", got.Announce)
}
if got.Locked == nil || *got.Locked {
t.Errorf("Locked: %+v", got.Locked)
}
if got.EphemeralSeconds != nil {
t.Errorf("EphemeralSeconds should be nil when absent, got %+v", *got.EphemeralSeconds)
}
}
// An update must only touch the settings that were set — unset pointer fields
// are omitted from the body so the server leaves them alone.
func TestUpdateGroupSettingsOmitsUnsetFields(t *testing.T) {
rt := &recordTransport{status: 200, body: `{"success":true,"message":"Group settings updated"}`}
c := newTestClient(t, rt)
res, err := c.Groups.UpdateGroupSettings(context.Background(), "s1", "g1", GroupSettings{Announce: Ptr(true)})
if err != nil {
t.Fatalf("UpdateGroupSettings: %v", err)
}
if !res.Success || res.Message != "Group settings updated" {
t.Fatalf("unexpected response: %+v", res)
}
if rt.lastReq.Method != "PUT" {
t.Fatalf("method = %q, want PUT", rt.lastReq.Method)
}
var sent map[string]any
if err := json.Unmarshal(rt.lastRaw, &sent); err != nil {
t.Fatalf("body not JSON: %v", err)
}
if sent["announce"] != true {
t.Fatalf("announce = %v", sent["announce"])
}
if _, ok := sent["locked"]; ok {
t.Fatal("unset locked should be omitted from body")
}
if _, ok := sent["ephemeralSeconds"]; ok {
t.Fatal("unset ephemeralSeconds should be omitted from body")
}
}
// A 503 is the gateway's answer when the engine never confirmed an operation: a transport failure,
// which is worth retrying, as a 429 is. It used to have no sentinel, while the permanent 501 did.
func TestServiceUnavailableIsRetryableSentinel(t *testing.T) {
rt := &recordTransport{
status: 503,
body: `{"statusCode":503,"message":"WhatsApp did not answer in time","error":"Service Unavailable"}`,
}
c := newTestClient(t, rt)
_, err := c.Groups.Get(context.Background(), "s1", "g1")
if !errors.Is(err, ErrServiceUnavailable) {
t.Fatalf("errors.Is ErrServiceUnavailable = false for %v", err)
}
// It must not also satisfy a sentinel that would mislead a caller into NOT retrying.
if errors.Is(err, ErrNotImplemented) {
t.Fatal("a 503 must not match ErrNotImplemented")
}
}
// Setting ephemeralSeconds on the whatsapp-web.js engine surfaces as 501.
func TestUpdateGroupSettingsNotImplemented(t *testing.T) {
rt := &recordTransport{
status: 501,
body: `{"statusCode":501,"message":"Engine does not support ephemeral messages","error":"Not Implemented"}`,
}
c := newTestClient(t, rt)
_, err := c.Groups.UpdateGroupSettings(context.Background(), "s1", "g1", GroupSettings{EphemeralSeconds: Ptr(86400)})
if !errors.Is(err, ErrNotImplemented) {
t.Fatalf("errors.Is ErrNotImplemented = false for %v", err)
}
}
func TestSetProfileName(t *testing.T) {
rt := &recordTransport{status: 200, body: `{"success":true,"message":"Profile name updated"}`}
c := newTestClient(t, rt)
res, err := c.Profile.SetProfileName(context.Background(), "s1", SetProfileNameRequest{Name: "Acme"})
if err != nil {
t.Fatalf("SetProfileName: %v", err)
}
if !res.Success {
t.Fatalf("unexpected response: %+v", res)
}
wantPath := "/api/sessions/s1/profile/name"
if got := rt.lastReq.URL.Path; got != wantPath {
t.Fatalf("path = %q, want %q", got, wantPath)
}
var sent SetProfileNameRequest
if err := json.Unmarshal(rt.lastRaw, &sent); err != nil {
t.Fatalf("body not JSON: %v", err)
}
if sent.Name != "Acme" {
t.Fatalf("sent body = %+v", sent)
}
}
// An empty status clears the about text — the field must still be sent.
func TestSetProfileStatusEmptyClears(t *testing.T) {
rt := &recordTransport{status: 200, body: `{"success":true,"message":"Profile status updated"}`}
c := newTestClient(t, rt)
if _, err := c.Profile.SetProfileStatus(context.Background(), "s1", SetProfileStatusRequest{Status: ""}); err != nil {
t.Fatalf("SetProfileStatus: %v", err)
}
if !strings.Contains(string(rt.lastRaw), `"status":""`) {
t.Fatalf("empty status must be sent, body = %s", rt.lastRaw)
}
}
// The picture body is either {url} or {base64, mimetype} — never a mix, and
// empty alternates are omitted.
func TestSetProfilePictureBody(t *testing.T) {
rt := &recordTransport{status: 200, body: `{"success":true,"message":"Profile picture updated"}`}
c := newTestClient(t, rt)
if _, err := c.Profile.SetProfilePicture(context.Background(), "s1", SetProfilePictureRequest{
Base64: "aW1hZ2U=",
Mimetype: "image/jpeg",
}); err != nil {
t.Fatalf("SetProfilePicture: %v", err)
}
var sent map[string]any
if err := json.Unmarshal(rt.lastRaw, &sent); err != nil {
t.Fatalf("body not JSON: %v", err)
}
if sent["base64"] != "aW1hZ2U=" || sent["mimetype"] != "image/jpeg" {
t.Fatalf("sent body = %v", sent)
}
if _, ok := sent["url"]; ok {
t.Fatal("empty url should be omitted from body")
}
}
func TestRejectCall(t *testing.T) {
rt := &recordTransport{status: 200, body: `{"success":true}`}
c := newTestClient(t, rt)
res, err := c.Calls.RejectCall(context.Background(), "s1", "call-1")
if err != nil {
t.Fatalf("RejectCall: %v", err)
}
if !res.Success {
t.Fatalf("unexpected response: %+v", res)
}
wantPath := "/api/sessions/s1/calls/call-1/reject"
if got := rt.lastReq.URL.Path; got != wantPath {
t.Fatalf("path = %q, want %q", got, wantPath)
}
if rt.lastReq.Method != "POST" {
t.Fatalf("method = %q, want POST", rt.lastReq.Method)
}
}
// A call that is no longer ringing surfaces as 404.
func TestRejectCallNotRinging(t *testing.T) {
rt := &recordTransport{
status: 404,
body: `{"statusCode":404,"message":"Call not found or no longer ringing","error":"Not Found"}`,
}
c := newTestClient(t, rt)
_, err := c.Calls.RejectCall(context.Background(), "s1", "call-1")
if !errors.Is(err, ErrNotFound) {
t.Fatalf("errors.Is ErrNotFound = false for %v", err)
}
}
// The Event* constants are the wire values of the server's WEBHOOK_EVENTS
// catalog — a typo here silently subscribes to nothing.
func TestWebhookEventWireValues(t *testing.T) {
want := map[WebhookEvent]string{
EventMessageReceived: "message.received",
EventMessageSent: "message.sent",
EventMessageAck: "message.ack",
EventMessageReceipt: "message.receipt",
EventMessageFailed: "message.failed",
EventMessageRevoked: "message.revoked",
EventMessageReaction: "message.reaction",
EventMessageEdited: "message.edited",
EventSessionStatus: "session.status",
EventSessionQR: "session.qr",
EventSessionAuthenticated: "session.authenticated",
EventSessionDisconnected: "session.disconnected",
EventSessionReconnectLoop: "session.reconnect_loop",
EventSessionRestriction: "session.restriction",
EventPresenceUpdate: "presence.update",
EventEventResponse: "event.response",
EventPollVote: "poll.vote",
EventCallAccepted: "call.accepted",
EventCallRejected: "call.rejected",
EventCallMissed: "call.missed",
EventGroupJoin: "group.join",
EventGroupLeave: "group.leave",
EventGroupUpdate: "group.update",
EventGroupJoinRequest: "group.join_request",
EventCallReceived: "call.received",
EventStatusReceived: "status.received",
EventAll: "*",
}
for got, w := range want {
if got != w {
t.Errorf("event constant = %q, want %q", got, w)
}
}
}
// The group event payload decodes join/leave (participants, no changes) and
// update (changes delta, empty participants) shapes alike.
func TestGroupEventPayloadDecodes(t *testing.T) {
join := `{"groupId":"[email protected]","actorId":"[email protected]","participantIds":["[email protected]"],"timestamp":1700000000}`
var j GroupEventPayload
if err := json.Unmarshal([]byte(join), &j); err != nil {
t.Fatalf("join payload: %v", err)
}
if j.GroupID != "[email protected]" || j.ActorID == nil || *j.ActorID != "[email protected]" {
t.Fatalf("join decode: %+v", j)
}
if len(j.ParticipantIDs) != 1 || j.ParticipantIDs[0] != "[email protected]" {
t.Fatalf("join participants: %+v", j.ParticipantIDs)
}
if j.Changes != nil {
t.Fatalf("join should carry no changes, got %+v", j.Changes)
}
update := `{"groupId":"[email protected]","participantIds":[],"changes":{"subject":"New","locked":true},"timestamp":1700000001}`
var u GroupEventPayload
if err := json.Unmarshal([]byte(update), &u); err != nil {
t.Fatalf("update payload: %v", err)
}
if u.Changes == nil || u.Changes.Subject == nil || *u.Changes.Subject != "New" {
t.Fatalf("update changes: %+v", u.Changes)
}
if u.Changes.Locked == nil || !*u.Changes.Locked {
t.Fatalf("update locked: %+v", u.Changes.Locked)
}
if u.Changes.Announce != nil || u.Changes.Description != nil {
t.Fatalf("unchanged settings must stay nil: %+v", u.Changes)
}
}
func TestCallReceivedPayloadDecodes(t *testing.T) {
body := `{"callId":"call-1","from":"[email protected]","isVideo":true,"isGroup":false,"timestamp":1700000000}`
var p CallReceivedPayload
if err := json.Unmarshal([]byte(body), &p); err != nil {
t.Fatalf("call payload: %v", err)
}
if p.CallID != "call-1" || p.From != "[email protected]" || !p.IsVideo || p.IsGroup || p.Timestamp != 1700000000 {
t.Fatalf("call decode: %+v", p)
}
}
// SendAudioRequest is flattened rather than embedding SendMediaRequest, because ptt is accepted on
// this route alone. The flattening is what dropped mentions here while every other send carried it,
// so this asserts the wire body rather than the call.
func TestSendAudioForwardsMentions(t *testing.T) {
rt := &recordTransport{status: 200, body: `{"messageId":"m1","timestamp":1}`}
c := newTestClient(t, rt)
if _, err := c.Messages.SendAudio(context.Background(), "s1", SendAudioRequest{
ChatID: "[email protected]",
URL: "http://u",
Mentions: []string{"[email protected]"},
}); err != nil {
t.Fatalf("SendAudio: %v", err)
}
var sent map[string]any
if err := json.Unmarshal(rt.lastRaw, &sent); err != nil {
t.Fatalf("body not JSON: %v", err)
}
mentions, ok := sent["mentions"].([]any)
if !ok || len(mentions) != 1 || mentions[0] != "[email protected]" {
t.Fatalf("sent body = %v", sent)
}
}
func TestSendTextForwardsMentions(t *testing.T) {
rt := &recordTransport{status: 200, body: `{"messageId":"m1","timestamp":1}`}
c := newTestClient(t, rt)
if _, err := c.Messages.SendText(context.Background(), "s1", SendTextRequest{
ChatID: "[email protected]",
Text: "hi @628123",
Mentions: []string{"[email protected]"},
}); err != nil {
t.Fatalf("SendText: %v", err)
}
var sent map[string]any
if err := json.Unmarshal(rt.lastRaw, &sent); err != nil {
t.Fatalf("body not JSON: %v", err)
}
mentions, ok := sent["mentions"].([]any)
if !ok || len(mentions) != 1 || mentions[0] != "[email protected]" {
t.Fatalf("sent body = %v", sent)
}
}
func TestSendPollHitsCorrectPath(t *testing.T) {
rt := &recordTransport{status: 200, body: `{"messageId":"m2","timestamp":2}`}
c := newTestClient(t, rt)
res, err := c.Messages.SendPoll(context.Background(), "s1", SendPollRequest{
ChatID: "[email protected]",
Name: "Where?",
Options: []string{"Park", "Beach"},
AllowMultipleAnswers: Ptr(true),
})
if err != nil {
t.Fatalf("SendPoll: %v", err)
}
if res.MessageID != "m2" {
t.Fatalf("unexpected response: %+v", res)
}
wantPath := "/api/sessions/s1/messages/send-poll"
if got := rt.lastReq.URL.Path; got != wantPath {
t.Fatalf("path = %q, want %q", got, wantPath)
}
if rt.lastReq.Method != "POST" {
t.Fatalf("method = %q, want POST", rt.lastReq.Method)
}
var sent map[string]any
if err := json.Unmarshal(rt.lastRaw, &sent); err != nil {
t.Fatalf("body not JSON: %v", err)
}
if sent["name"] != "Where?" || sent["allowMultipleAnswers"] != true {
t.Fatalf("sent body = %v", sent)
}
options, ok := sent["options"].([]any)
if !ok || len(options) != 2 || options[0] != "Park" || options[1] != "Beach" {
t.Fatalf("sent options = %v", sent["options"])
}
}
func TestProfilePicturesBatchQuery(t *testing.T) {
rt := &recordTransport{status: 200, body: `{"pictures":{"[email protected]":"http://p/a","[email protected]":null}}`}
c := newTestClient(t, rt)
res, err := c.Contacts.ProfilePictures(context.Background(), "s1", []string{"[email protected]", "[email protected]"})
if err != nil {
t.Fatalf("ProfilePictures: %v", err)
}
if rt.lastReq.Method != "GET" {
t.Fatalf("method = %q, want GET", rt.lastReq.Method)
}
wantPath := "/api/sessions/s1/contacts/profile-pictures"
if got := rt.lastReq.URL.Path; got != wantPath {
t.Fatalf("path = %q, want %q", got, wantPath)
}
if got := rt.lastReq.URL.Query().Get("ids"); got != "[email protected],[email protected]" {
t.Fatalf("ids query = %q", got)
}
if res.Pictures["[email protected]"] == nil || *res.Pictures["[email protected]"] != "http://p/a" {
t.Fatalf("pictures[[email protected]] = %v", res.Pictures["[email protected]"])
}
if url, present := res.Pictures["[email protected]"]; !present || url != nil {
t.Fatalf("pictures[[email protected]] should decode as an explicit null, got %v (present=%v)", url, present)
}
}
func TestStatusMediaReturnsBytes(t *testing.T) {
rt := &recordTransport{
status: 200,
body: "PNG_BYTES",
header: http.Header{"Content-Type": []string{"image/png"}},
}
c := newTestClient(t, rt)
media, err := c.Status.Media(context.Background(), "s1", "w1")
if err != nil {
t.Fatalf("Media: %v", err)
}
if string(media.Data) != "PNG_BYTES" || media.ContentType != "image/png" {
t.Fatalf("media = %q (%q)", media.Data, media.ContentType)
}
wantPath := "/api/sessions/s1/status/w1/media"
if got := rt.lastReq.URL.Path; got != wantPath {
t.Fatalf("path = %q, want %q", got, wantPath)
}
if rt.lastReq.Method != "GET" {
t.Fatalf("method = %q, want GET", rt.lastReq.Method)
}
}
// A status with no stored media surfaces as 404.
func TestStatusMediaNotFound(t *testing.T) {
rt := &recordTransport{
status: 404,
body: `{"statusCode":404,"message":"Status media not found or expired","error":"Not Found"}`,
}
c := newTestClient(t, rt)
_, err := c.Status.Media(context.Background(), "s1", "w1")
if !errors.Is(err, ErrNotFound) {
t.Fatalf("errors.Is ErrNotFound = false for %v", err)
}
}
// The escape hatch mirrors the JS/Python/PHP raw-text fallback for non-JSON
// 2xx bodies: *[]byte takes the body verbatim, *string falls back to raw text,
// and a typed target still requires JSON.
func TestDoRawFallbacks(t *testing.T) {
ctx := context.Background()
t.Run("bytes take the body verbatim", func(t *testing.T) {
rt := &recordTransport{status: 200, body: "PNG_BYTES", header: http.Header{"Content-Type": []string{"image/png"}}}
c := newTestClient(t, rt)
var raw []byte
if err := c.Do(ctx, "GET", "/api/x", nil, nil, &raw); err != nil {
t.Fatalf("Do: %v", err)
}
if string(raw) != "PNG_BYTES" {
t.Fatalf("raw = %q", raw)
}
})
t.Run("string falls back to raw text on non-JSON", func(t *testing.T) {
rt := &recordTransport{status: 200, body: "plain text"}
c := newTestClient(t, rt)
var s string
if err := c.Do(ctx, "GET", "/api/x", nil, nil, &s); err != nil {
t.Fatalf("Do: %v", err)
}
if s != "plain text" {
t.Fatalf("s = %q", s)
}
})
t.Run("string still decodes a JSON string body", func(t *testing.T) {
rt := &recordTransport{status: 200, body: `"quoted"`}
c := newTestClient(t, rt)
var s string
if err := c.Do(ctx, "GET", "/api/x", nil, nil, &s); err != nil {
t.Fatalf("Do: %v", err)
}
if s != "quoted" {
t.Fatalf("s = %q", s)
}
})
t.Run("typed target still requires JSON", func(t *testing.T) {
rt := &recordTransport{status: 200, body: "plain text"}
c := newTestClient(t, rt)
var out MessageResponse
if err := c.Do(ctx, "GET", "/api/x", nil, nil, &out); err == nil {
t.Fatal("expected a decode error for a non-JSON body into a typed target")
}
})
}
// The filter value is polymorphic on the wire: a string for text fields, a
// string array for id/enum fields, a bool for boolean fields, plus the
// caseSensitive flag — all must serialize verbatim.
func TestWebhookFiltersPolymorphicWireShape(t *testing.T) {
rt := &recordTransport{status: 200, body: `{"id":"w1"}`}
c := newTestClient(t, rt)
_, err := c.Webhooks.Create(context.Background(), "s1", CreateWebhookRequest{
URL: "https://example.com/hook",
Events: []string{EventMessageReceived},
Filters: &WebhookFilters{
Conditions: []WebhookFilterCondition{
{Field: "sender", Operator: "is", Value: []string{"[email protected]"}},
{Field: "body", Operator: "contains", Value: "invoice", CaseSensitive: Ptr(true)},
{Field: "isGroup", Operator: "is", Value: false},
},
},
})
if err != nil {
t.Fatalf("Create: %v", err)
}
var sent map[string]any
if err := json.Unmarshal(rt.lastRaw, &sent); err != nil {
t.Fatalf("body not JSON: %v", err)
}
conditions := sent["filters"].(map[string]any)["conditions"].([]any)
if len(conditions) != 3 {
t.Fatalf("conditions = %v", conditions)
}
first := conditions[0].(map[string]any)
if values, ok := first["value"].([]any); !ok || len(values) != 1 || values[0] != "[email protected]" {
t.Fatalf("id condition value = %v", first["value"])
}
second := conditions[1].(map[string]any)
if second["value"] != "invoice" || second["caseSensitive"] != true {
t.Fatalf("text condition = %v", second)
}
third := conditions[2].(map[string]any)
if third["value"] != false {
t.Fatalf("boolean condition value = %v", third["value"])
}
if _, present := first["caseSensitive"]; present {
t.Fatal("caseSensitive should be omitted when unset")
}
}
func TestMediaConversionStatus(t *testing.T) {
rt := &recordTransport{status: 200, body: `{"available":true}`}
c := newTestClient(t, rt)
res, err := c.Media.ConversionStatus(context.Background(), "s1")
if err != nil {
t.Fatalf("ConversionStatus: %v", err)
}
if !res.Available {
t.Fatalf("unexpected response: %+v", res)
}
if got, want := rt.lastReq.URL.Path, "/api/sessions/s1/media/convert"; got != want {
t.Fatalf("path = %q, want %q", got, want)
}
if rt.lastReq.Method != "GET" {
t.Fatalf("method = %q, want GET", rt.lastReq.Method)
}
}
func TestConvertVoice(t *testing.T) {
rt := &recordTransport{status: 200, body: `{"base64":"T2dnUw==","mimetype":"audio/ogg; codecs=opus","bytes":8}`}
c := newTestClient(t, rt)
res, err := c.Media.ConvertVoice(context.Background(), "s1", ConvertMediaInput{Base64: "SUQz"})
if err != nil {
t.Fatalf("ConvertVoice: %v", err)
}
if res.Mimetype != "audio/ogg; codecs=opus" || res.Bytes != 8 {
t.Fatalf("unexpected response: %+v", res)
}
if got, want := rt.lastReq.URL.Path, "/api/sessions/s1/media/convert/voice"; got != want {
t.Fatalf("path = %q, want %q", got, want)
}
// An unset URL must be omitted rather than sent as an empty string, which the
// server would read as a supplied-but-blank field.
if got := string(rt.lastRaw); got != `{"base64":"SUQz"}` {
t.Fatalf("body = %s, want {\"base64\":\"SUQz\"}", got)
}
}
func TestConvertVideo(t *testing.T) {
rt := &recordTransport{status: 200, body: `{"base64":"AAAA","mimetype":"video/mp4","bytes":4}`}
c := newTestClient(t, rt)
if _, err := c.Media.ConvertVideo(context.Background(), "s1", ConvertMediaInput{URL: "https://example.com/c.mov"}); err != nil {
t.Fatalf("ConvertVideo: %v", err)
}
if got, want := rt.lastReq.URL.Path, "/api/sessions/s1/media/convert/video"; got != want {
t.Fatalf("path = %q, want %q", got, want)
}
if got := string(rt.lastRaw); got != `{"url":"https://example.com/c.mov"}` {
t.Fatalf("body = %s, want the url only", got)
}
}
// The config route needs three states per field: absent leaves it unchanged, explicit null clears it
// to the default, a value sets it. A *int with omitempty could only ever express two — a nil pointer
// was OMITTED, so restoring unlimited reconnect attempts was unreachable through this SDK.
func TestUpdateSessionConfigEmitsThreeStates(t *testing.T) {
cases := []struct {
name string
req UpdateSessionConfigRequest
want string
}{
{"absent leaves everything unchanged", UpdateSessionConfigRequest{}, `{}`},
{"a value sets it", UpdateSessionConfigRequest{MaxReconnectAttempts: Ptr(5)}, `{"maxReconnectAttempts":5}`},
{"clear sends explicit null", UpdateSessionConfigRequest{ClearMaxReconnectAttempts: true}, `{"maxReconnectAttempts":null}`},
{"clear wins over a value", UpdateSessionConfigRequest{MaxReconnectAttempts: Ptr(5), ClearMaxReconnectAttempts: true}, `{"maxReconnectAttempts":null}`},
}
for _, c := range cases {
b, err := json.Marshal(c.req)
if err != nil {
t.Fatalf("%s: %v", c.name, err)
}
if string(b) != c.want {
t.Fatalf("%s: got %s, want %s", c.name, b, c.want)
}
}
}
// The request enums are named types, so a Go value can no longer be an arbitrary string. What the
// compiler cannot check is the value each constant CARRIES: these fields travel as their
// underlying string or number, and a typo would be refused by the server, not by the build.
func TestRequestEnumWireValues(t *testing.T) {
wireStrings := map[string]string{
string(CallLinkAudio): "audio",
string(CallLinkVideo): "video",
string(ProxyHTTP): "http",
string(ProxyHTTPS): "https",
string(ProxySOCKS4): "socks4",
string(ProxySOCKS5): "socks5",
string(MembershipInviteLink): "invite_link",
string(MembershipLinkedGroupJoin): "linked_group_join",
string(MembershipNonAdminAdd): "non_admin_add",
string(ChatStateTyping): "typing",
string(ChatStateRecording): "recording",
string(ChatStatePaused): "paused",
}
for got, want := range wireStrings {
if got != want {
t.Errorf("wire value = %q, want %q", got, want)
}
}
wireNumbers := map[int]int{
int(PinOneDay): 86400,
int(PinSevenDays): 604800,
int(PinThirtyDays): 2592000,
int(StatusFontDefault): 0,
int(StatusFontBold): 6,
int(StatusFontBryndan): 10,
}
for got, want := range wireNumbers {
if got != want {
t.Errorf("wire value = %d, want %d", got, want)
}
}
// The named types must still marshal as bare JSON scalars, not as objects or quoted numbers.
body, err := json.Marshal(SendChatStateRequest{ChatID: "[email protected]", State: ChatStateTyping})
if err != nil {
t.Fatalf("marshal: %v", err)
}
if !strings.Contains(string(body), `"state":"typing"`) {
t.Errorf("state did not marshal as a bare string: %s", body)
}
pin, err := json.Marshal(PinMessageRequest{ChatID: "[email protected]", MessageID: "m", DurationSeconds: PinOneDay})
if err != nil {
t.Fatalf("marshal: %v", err)
}
if !strings.Contains(string(pin), `"durationSeconds":86400`) {
t.Errorf("durationSeconds did not marshal as a bare number: %s", pin)
}
}
// A Do path that does not begin with "/" would be appended to the base URL's
// authority, so "@evil.example/x" sends the API key to evil.example.
func TestDoPathWithoutLeadingSlashRefused(t *testing.T) {
rt := &recordTransport{status: 200, body: `{}`}
c := newTestClient(t, rt)
for _, path := range []string{"@evil.example/api/x", ".evil.example/api/x", "api/x", ""} {
if err := c.Do(context.Background(), "GET", path, nil, nil, nil); err == nil {
t.Errorf("Do %q: want an error", path)
}
}
if rt.lastReq != nil {
t.Fatalf("request sent to %s, want none", rt.lastReq.URL.Host)
}
}
// stallServer stalls every request before answering; with flush set it sends
// the headers first and stalls the body instead. It blocks until the request is
// cancelled or the test ends.
func stallServer(t *testing.T, flush bool) *httptest.Server {
t.Helper()
release := make(chan struct{})
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if flush {
w.Header().Set("Content-Type", "application/octet-stream")
w.WriteHeader(http.StatusOK)
_, _ = w.Write([]byte("partial"))
w.(http.Flusher).Flush()
}
select {
case <-r.Context().Done():
case <-release:
}
}))
t.Cleanup(srv.Close)
t.Cleanup(func() { close(release) })
return srv
}
func TestTimeoutReportsTheBudgetThatExpired(t *testing.T) {
for _, flush := range []bool{false, true} {
srv := stallServer(t, flush)
// The client timeout fired: the error names it.
c, err := New(srv.URL, "k", WithTimeout(100*time.Millisecond))
if err != nil {
t.Fatalf("New: %v", err)
}
_, err = c.Messages.Media(context.Background(), "s1", "c1", "m1")
var te *TimeoutError
if !errors.As(err, &te) || te.Timeout != 100*time.Millisecond {
t.Errorf("flush=%v client timeout: err = %v, want a *TimeoutError after 100ms", flush, err)
}
// The caller's shorter deadline fired: the 30s client timeout is not the
// budget that ran out, so the error does not name it.
c, err = New(srv.URL, "k")
if err != nil {
t.Fatalf("New: %v", err)
}
ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
_, err = c.Messages.Media(ctx, "s1", "c1", "m1")
cancel()
te = nil
if !errors.As(err, &te) || te.Timeout != 0 || err.Error() != "openwa: request timed out" {
t.Errorf("flush=%v caller deadline: err = %v, want a *TimeoutError without a duration", flush, err)
}
}
}
// argsLogger records every logged key-value argument as text.
type argsLogger struct{ text strings.Builder }
func (l *argsLogger) Log(_ context.Context, _ string, msg string, args ...any) {
fmt.Fprintln(&l.text, msg, args)
}
// A base URL may carry basic-auth credentials for a fronting proxy; the
// password must not reach the request log.
func TestRequestLogRedactsBaseURLPassword(t *testing.T) {
ok := &recordTransport{status: 200, body: `{}`}
failing := RoundTripperFunc(func(*http.Request) (*http.Response, error) { return nil, errors.New("refused") })
for _, rt := range []http.RoundTripper{ok, failing} {
lg := &argsLogger{}
c, err := New("https://proxyuser:[email protected]", "k", WithTransport(rt), WithLogger(lg))
if err != nil {
t.Fatalf("New: %v", err)
}
_, _ = c.Health.Check(context.Background())
if got := lg.text.String(); !strings.Contains(got, "api.example.com") || strings.Contains(got, "s3cret") {
t.Errorf("request log = %q, want the URL without the password", got)
}
}
// The retry layer logs the URL of every request it replays.
lg := &argsLogger{}
policy := RetryPolicy{MaxRetries: 1, BaseDelay: time.Millisecond, MaxDelay: time.Millisecond}
c, err := New("https://proxyuser:[email protected]", "k",
WithTransport(&statusTransport{status: 503}), WithLogger(lg), WithRetry(policy))
if err != nil {
t.Fatalf("New: %v", err)
}
_, _ = c.Health.Check(context.Background())
if got := lg.text.String(); !strings.Contains(got, "openwa retrying request") || strings.Contains(got, "s3cret") {
t.Errorf("retry log = %q, want the retry logged without the password", got)
}
}
// A Do path that already carries a query string keeps it; the query values are appended with "&"
// rather than a second "?", which the server would read as part of the first value.
func TestDoPathWithQueryAppendsQueryValues(t *testing.T) {
for _, tc := range []struct{ path, want string }{
{"/api/sessions", "name=x&tag=a&tag=b"},
{"/api/sessions?limit=5", "limit=5&name=x&tag=a&tag=b"},
{"/api/sessions#client", "name=x&tag=a&tag=b"},
{"/api/sessions?limit=5#client", "limit=5&name=x&tag=a&tag=b"},
{"/api/sessions#client?x=1", "name=x&tag=a&tag=b"},
} {
t.Run(tc.path, func(t *testing.T) {
rt := &recordTransport{status: 200, body: `[]`}
c, err := New("https://api.example.com/prefix", "k", WithTransport(rt))
if err != nil {
t.Fatal(err)
}
if err := c.Do(context.Background(), "GET", tc.path, url.Values{"name": {"x"}, "tag": {"a", "b"}}, nil, nil); err != nil {
t.Fatal(err)
}
if got := rt.lastReq.URL.RawQuery; got != tc.want {
t.Errorf("query = %q, want %q", got, tc.want)
}
if got := rt.lastReq.URL.EscapedPath(); got != "/prefix/api/sessions" {
t.Errorf("path = %q, want the base URL prefix preserved", got)
}
})
}
}
// net/http sends the method as written and the gateway answers 400 to a lowercase one, so Do upper-cases
// it. The idempotency header and the retry policy compare the upper-case names too.
func TestDoSendsTheMethodInUpperCase(t *testing.T) {
rt := &recordTransport{status: 200, body: `{}`}
c := newTestClient(t, rt)
for _, tc := range []struct{ given, want string }{
{"get", "GET"}, {"post", "POST"}, {"put", "PUT"}, {"patch", "PATCH"}, {"delete", "DELETE"},
{"Patch", "PATCH"}, {"PATCH", "PATCH"},
} {
rt.lastReq = nil
if err := c.Do(context.Background(), tc.given, "/api/x", nil, nil, nil); err != nil {
t.Fatalf("Do(%q): %v", tc.given, err)
}
if got := rt.lastReq.Method; got != tc.want {
t.Errorf("Do(%q): the transport saw %q, want %q", tc.given, got, tc.want)
}
}
ctx := WithIdempotencyKey(context.Background(), "k1")
if err := c.Do(ctx, "post", "/api/sessions/s/messages/send-text", nil, map[string]string{"chatId": "x"}, nil); err != nil {
t.Fatal(err)
}
if got := rt.lastReq.Header.Get("Idempotency-Key"); got != "k1" {
t.Errorf("a lowercase post to a send route sent Idempotency-Key %q, want %q", got, "k1")
}
}
func TestSendIdempotencyKey(t *testing.T) {
rt := &recordTransport{status: 200, body: `{"messageId":"m","timestamp":1}`}
c := newTestClient(t, rt, WithHeader("idempotency-key", "default"))
for _, segment := range []string{"send-text", "send-image", "send-video", "send-audio", "send-document", "send-sticker", "send-location", "send-contact", "send-template", "send-poll", "reply", "forward"} {
ctx := WithIdempotencyKey(context.Background(), segment)
if _, err := c.Messages.send(ctx, "s", segment, map[string]string{"chatId": "x"}); err != nil {
t.Fatal(err)
}
if got := rt.lastReq.Header.Values("Idempotency-Key"); len(got) != 1 || got[0] != segment {
t.Fatalf("%s: %v", segment, got)
}
if string(rt.lastRaw) != `{"chatId":"x"}` {
t.Fatalf("body changed: %s", rt.lastRaw)
}
}
if _, err := c.Messages.SendText(context.Background(), "s", SendTextRequest{}); err != nil {
t.Fatal(err)
}
if got := rt.lastReq.Header.Get("Idempotency-Key"); got != "default" {
t.Fatalf("default mutated: %s", got)
}
for _, key := range []string{"", "a b", "a\n", "é", strings.Repeat("x", 256)} {
rt.lastReq = nil
if _, err := c.Messages.SendText(WithIdempotencyKey(context.Background(), key), "s", SendTextRequest{}); err == nil {
t.Fatalf("accepted %q", key)
}
if rt.lastReq != nil {
t.Fatalf("transport called for %q", key)
}
}
}
// The key is checked against the gateway's own rule: 1 to 255 characters, each a visible ASCII one
// from '!' to '~'. A boundary moved by one refuses keys the gateway takes, or sends one it refuses.
func TestIdempotencyKeyBoundaries(t *testing.T) {
rt := &recordTransport{status: 200, body: `{"messageId":"m","timestamp":1}`}
c := newTestClient(t, rt)
for _, tc := range []struct {
name string
key string
accept bool
}{
{"first visible character", "!", true},
{"last visible character", "~", true},
{"one character", "x", true},
{"longest key", strings.Repeat("x", 255), true},
{"one too long", strings.Repeat("x", 256), false},
{"empty", "", false},
{"space", " ", false},
{"delete", "a\x7fb", false},
} {
t.Run(tc.name, func(t *testing.T) {
rt.lastReq = nil
_, err := c.Messages.SendText(WithIdempotencyKey(context.Background(), tc.key), "s", SendTextRequest{})
if tc.accept {
if err != nil {
t.Fatalf("refused %q: %v", tc.key, err)
}
if got := rt.lastReq.Header.Get("Idempotency-Key"); got != tc.key {
t.Fatalf("header = %q, want %q", got, tc.key)
}
return
}
if err == nil || rt.lastReq != nil {
t.Fatalf("accepted %q (err %v, sent %v)", tc.key, err, rt.lastReq != nil)
}
})
}
}
// A nil context is the caller's mistake, and net/http names it as an error. The idempotency lookup must
// not turn it into a panic that takes the calling program down.
func TestNilContextReturnsAnErrorInsteadOfPanicking(t *testing.T) {
rt := &recordTransport{status: 200, body: `{}`}
c := newTestClient(t, rt)
defer func() {
if r := recover(); r != nil {
t.Fatalf("a nil context panicked: %v", r)
}
}()
//nolint:staticcheck // the nil context is the point of the test
if _, err := c.Messages.SendText(nil, "s", SendTextRequest{}); err == nil {
t.Fatal("a nil context was accepted")
}
if rt.lastReq != nil {
t.Fatal("a request was sent with a nil context")
}
}
func TestRedrivePreservesAnEmptyIDsFilter(t *testing.T) {
rt := &recordTransport{status: 200, body: `{}`}
c := newTestClient(t, rt)
var zero []string
empty := []string{}
selected := []string{"f1"}
for _, tc := range []struct {
name string
ids *[]string
want string
}{
{"omitted", nil, `{}`},
{"nil slice", &zero, `{"ids":[]}`},
{"empty slice", &empty, `{"ids":[]}`},
{"selected rows", &selected, `{"ids":["f1"]}`},
} {
t.Run(tc.name, func(t *testing.T) {
body := &RedriveWebhookDeliveriesRequest{IDs: tc.ids}
if _, err := c.Webhooks.RedriveDeliveryFailures(context.Background(), body); err != nil {
t.Fatal(err)
}
if string(rt.lastRaw) != tc.want {
t.Fatalf("body = %s, want %s", rt.lastRaw, tc.want)
}
if body.IDs != tc.ids || zero != nil {
t.Fatal("request IDs mutated")
}
})
}
}
func TestRetryKeepsIdempotencyKey(t *testing.T) {
var keys []string
rt := RoundTripperFunc(func(req *http.Request) (*http.Response, error) {
keys = append(keys, req.Header.Get("Idempotency-Key"))
return &http.Response{StatusCode: 503, Header: http.Header{}, Body: io.NopCloser(strings.NewReader(`{}`)), Request: req}, nil
})
c := newTestClient(t, rt, WithRetry(RetryPolicy{MaxRetries: 2, BaseDelay: time.Millisecond, MaxDelay: time.Millisecond, RetryableStatuses: []int{503}}))
_, _ = c.Messages.SendText(WithIdempotencyKey(context.Background(), "stable"), "s", SendTextRequest{})
if len(keys) != 3 {
t.Fatalf("attempts: %v", keys)
}
for _, key := range keys {
if key != "stable" {
t.Fatalf("keys: %v", keys)
}
}
}
// The status font ids are the wire values of the Baileys protocol's ExtendedTextMessage.FontType. The
// constants carry the protocol's names; the first-release names for the same ids stay as deprecated
// aliases so existing code keeps compiling and sending the same numbers.
func TestStatusFontConstants(t *testing.T) {
cases := []struct {
name string
got StatusFont
want int
}{
{"SYSTEM", StatusFontDefault, 0},
{"SYSTEM_TEXT", StatusFontSystemText, 1},
{"FB_SCRIPT", StatusFontFBScript, 2},
{"SYSTEM_BOLD", StatusFontBold, 6},
{"MORNINGBREEZE_REGULAR", StatusFontMorningBreezeRegular, 7},
{"CALISTOGA_REGULAR", StatusFontCalistogaRegular, 8},
{"EXO2_EXTRABOLD", StatusFontExo2ExtraBold, 9},
{"COURIERPRIME_BOLD", StatusFontCourierPrimeBold, 10},
}
for _, c := range cases {
if int(c.got) != c.want {
t.Errorf("%s = %d, want %d", c.name, c.got, c.want)
}
}
aliases := []struct {
name string
old StatusFont
want StatusFont
}{
{"StatusFontSerif", StatusFontSerif, StatusFontSystemText},
{"StatusFontNorican", StatusFontNorican, StatusFontFBScript},
{"StatusFontOswald", StatusFontOswald, StatusFontMorningBreezeRegular},
{"StatusFontDamion", StatusFontDamion, StatusFontCalistogaRegular},
{"StatusFontMorningbreeze", StatusFontMorningbreeze, StatusFontExo2ExtraBold},
{"StatusFontBryndan", StatusFontBryndan, StatusFontCourierPrimeBold},
}
for _, a := range aliases {
if a.old != a.want {
t.Errorf("%s = %d, want the wire value %d it always had", a.name, a.old, a.want)
}
}
body, err := json.Marshal(SendTextStatusRequest{Text: "hi", Font: Ptr(StatusFontCourierPrimeBold)})
if err != nil {
t.Fatalf("marshal: %v", err)
}
if !strings.Contains(string(body), `"font":10`) {
t.Errorf("font did not marshal as a bare number: %s", body)
}
}
func TestReservedCharactersStayInTypedPathSegment(t *testing.T) {
rt := &recordTransport{status: 200, body: `{}`}
c := newTestClient(t, rt)
if _, err := c.Contacts.Get(context.Background(), "s", "a/b?c#d"); err != nil {
t.Fatal(err)
}
if got := rt.lastReq.URL.EscapedPath(); got != "/api/sessions/s/contacts/a%2Fb%3Fc%23d" {
t.Errorf("escaped path = %q", got)
}
if rt.lastReq.URL.RawQuery != "" || rt.lastReq.URL.Fragment != "" {
t.Errorf("the ID moved into query or fragment: %s", rt.lastReq.URL)
}
}
func TestNon2xxResponsesDoNotDecodeSuccess(t *testing.T) {
for _, status := range []int{101, 199, 200, 204, 299, 300, 503} {
for _, kind := range []string{"json", "bytes"} {
t.Run(fmt.Sprintf("%d/%s", status, kind), func(t *testing.T) {
body := `{"ok":true}`
if status == 204 {
body = ""
}
c := newTestClient(t, &recordTransport{status: status, body: body})
var parsed map[string]any
var raw []byte
var out any = &parsed
if kind == "bytes" {
out = &raw
}
err := c.Do(context.Background(), "GET", "/api/x", nil, nil, out)
if status < 200 || status >= 300 {
var apiErr *APIError
if !errors.As(err, &apiErr) || apiErr.StatusCode != status {
t.Errorf("error = %v, want APIError with status %d", err, status)
}
if parsed != nil || raw != nil {
t.Error("an error response decoded a success body")
}
} else if err != nil {
t.Fatal(err)
} else if status == 204 {
if parsed != nil || len(raw) != 0 {
t.Error("204 should keep an empty body")
}
} else if kind == "json" && parsed["ok"] != true {
t.Errorf("decoded JSON = %v", parsed)
} else if kind == "bytes" && string(raw) != body {
t.Errorf("decoded bytes = %q, want %q", raw, body)
}
})
}
}
}
func TestRetryAfterDurationBounds(t *testing.T) {
const longest = time.Duration(1<<63 - 1)
for _, tc := range []struct {
name, header string
want time.Duration
valid bool
}{
{"zero", "0", 0, true},
{"small", "2", 2 * time.Second, true},
{"positive sign", "+2", 2 * time.Second, true},
{"negative zero", "-0", 0, true},
{"leading zeroes", strings.Repeat("0", 80) + "2", 2 * time.Second, true},
{"last whole second", "9223372036", 9223372036000000000, true},
{"overflow boundary", "9223372037", longest, true},
{"max integer", "9223372036854775807", longest, true},
{"oversized integer", strings.Repeat("9", 80), longest, true},
{"oversized positive integer", "+" + strings.Repeat("9", 80), longest, true},
{"negative", "-1", 0, false},
{"oversized negative integer", "-" + strings.Repeat("9", 80), 0, false},
{"fraction", "0.25", 0, false},
{"invalid suffix after overflow", strings.Repeat("9", 80) + "x", 0, false},
{"invalid", "soon", 0, false},
{"sign only", "+", 0, false},
} {
t.Run(tc.name, func(t *testing.T) {
got, valid := retryAfterHeader(http.Header{"Retry-After": {tc.header}})
if got != tc.want || valid != tc.valid {
t.Errorf("duration = %s, valid = %v; want %s, %v", got, valid, tc.want, tc.valid)
}
})
}
for _, tc := range []struct {
name, body string
want time.Duration
}{
{"small body", `{"retryAfterSeconds":2}`, 2 * time.Second},
{"fractional body", `{"retryAfterSeconds":0.25}`, 250 * time.Millisecond},
{"zero body overrides header", `{"retryAfterSeconds":0}`, 0},
{"negative body uses header", `{"retryAfterSeconds":-1}`, 7 * time.Second},
{"missing body delay uses header", `{}`, 7 * time.Second},
{"wrong body type uses header", `{"retryAfterSeconds":"2"}`, 7 * time.Second},
{"large body overrides header", `{"retryAfterSeconds":1e20}`, longest},
} {
t.Run(tc.name, func(t *testing.T) {
got := parseAPIError(429, []byte(tc.body), "GET /x", http.Header{"Retry-After": {"7"}})
if got.RetryAfter != tc.want {
t.Errorf("RetryAfter = %s, want %s", got.RetryAfter, tc.want)
}
})
}
}
func TestRetryDoesNotResendBeforeOversizedRetryAfter(t *testing.T) {
for _, status := range []int{429, 503} {
for _, header := range []string{"9223372037", strings.Repeat("9", 80)} {
for _, respect := range []bool{true, false} {
t.Run(fmt.Sprintf("%d/%s/respect=%v", status, header, respect), func(t *testing.T) {
var calls int32
rt := RoundTripperFunc(func(req *http.Request) (*http.Response, error) {
if atomic.AddInt32(&calls, 1) == 1 {
return &http.Response{StatusCode: status, Header: http.Header{"Retry-After": {header}}, Body: io.NopCloser(strings.NewReader(`{}`)), Request: req}, nil
}
return &http.Response{StatusCode: 200, Header: http.Header{}, Body: io.NopCloser(strings.NewReader(`{}`)), Request: req}, nil
})
c := newTestClient(t, rt, WithTimeout(500*time.Millisecond), WithRetry(RetryPolicy{
MaxRetries: 1, BaseDelay: time.Millisecond, MaxDelay: time.Millisecond, RespectRetryAfter: respect,
}))
err := c.Do(context.Background(), "GET", "/api/x", nil, nil, nil)
if !respect {
if err != nil || calls != 2 {
t.Errorf("disabled Retry-After: error = %v, calls = %d", err, calls)
}
return
}
var apiErr *APIError
if !errors.As(err, &apiErr) || apiErr.StatusCode != status || apiErr.RetryAfter <= 0 || calls != 1 {
t.Errorf("error = %v, calls = %d; want the first response without a retry", err, calls)
}
})
}
}
}
}
type responseReadErrorBody struct {
reads, closed int
}
func (b *responseReadErrorBody) Read(p []byte) (int, error) {
b.reads++
return copy(p, `{"code":`), io.ErrUnexpectedEOF
}
func (b *responseReadErrorBody) Close() error {
b.closed++
return nil
}
func TestRetryPreservesResponseBodyReadError(t *testing.T) {
for _, status := range []int{200, 429} {
t.Run(fmt.Sprint(status), func(t *testing.T) {
body := &responseReadErrorBody{}
var calls int32
c := newTestClient(t, RoundTripperFunc(func(req *http.Request) (*http.Response, error) {
atomic.AddInt32(&calls, 1)
return &http.Response{StatusCode: status, Header: http.Header{"Retry-After": {"3600"}}, Body: body, Request: req}, nil
}), WithTimeout(500*time.Millisecond), WithRetry(DefaultRetryPolicy()))
err := c.Do(context.Background(), "GET", "/api/x", nil, nil, nil)
if !errors.Is(err, io.ErrUnexpectedEOF) {
t.Errorf("error = %v, want preserved io.ErrUnexpectedEOF", err)
}
if calls != 1 || body.reads != 1 || body.closed != 1 {
t.Errorf("calls = %d, reads = %d, closes = %d; want one each", calls, body.reads, body.closed)
}
})
}
}
func TestRetryPreservesResponseBodyTimeout(t *testing.T) {
for _, status := range []int{200, 429} {
for _, callerDeadline := range []bool{false, true} {
t.Run(fmt.Sprintf("%d/caller=%v", status, callerDeadline), func(t *testing.T) {
var calls int32
started := make(chan struct{}, 1)
finished := make(chan struct{}, 1)
release := make(chan struct{})
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
atomic.AddInt32(&calls, 1)
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(status)
_, _ = w.Write([]byte(`{"code":`))
w.(http.Flusher).Flush()
select {
case started <- struct{}{}:
default:
}
select {
case <-r.Context().Done():
case <-release:
}
select {
case finished <- struct{}{}:
default:
}
}))
t.Cleanup(srv.Close)
t.Cleanup(func() { close(release) })
ctx := context.Background()
wantTimeout := 125 * time.Millisecond
opts := []Option{WithRetry(DefaultRetryPolicy())}
if callerDeadline {
var cancel context.CancelFunc
ctx, cancel = context.WithTimeout(ctx, wantTimeout)
defer cancel()
wantTimeout = 0
} else {
opts = append(opts, WithTimeout(wantTimeout))
}
c, err := New(srv.URL, "k", opts...)
if err != nil {
t.Fatal(err)
}
err = c.Do(ctx, "GET", "/api/x", nil, nil, nil)
select {
case <-started:
default:
t.Fatal("the response body was not flushed")
}
var te *TimeoutError
if !errors.As(err, &te) || te.Timeout != wantTimeout {
t.Errorf("error = %v, want a TimeoutError with budget %s", err, wantTimeout)
}
if got := atomic.LoadInt32(&calls); got != 1 {
t.Errorf("calls = %d, want one", got)
}
select {
case <-finished:
case <-time.After(2 * time.Second):
t.Error("cancellation did not release the server handler")
}
})
}
}
}