test: cover message thread read receipts

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: bf00a0ac-e11f-4015-b295-3cdd9b491229

Author: AchoArnold

tests/README.md

@@ -53,6 +53,7 @@ The API's Firebase SDK is configured (via `FCM_ENDPOINT` env var) to redirect al
 
 - [x] **Send SMS E2E** — Full send lifecycle: API → FCM push → emulator responds with SENT/DELIVERED events → message reaches `delivered` status
 - [x] **Receive SMS E2E** — Phone submits received message to API → message is stored and retrievable via GET endpoint
+- [x] **Message thread read receipts E2E** — Incoming SMS and missed calls mark a thread unread, the existing thread update endpoint marks it read, and outbound activity preserves unread state
 
 ## Prerequisites
 

tests/read_receipts_test.go

@@ -0,0 +1,192 @@
+package tests
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"testing"
+	"time"
+
+	httpsms "github.com/NdoleStudio/httpsms-go"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+type integrationMessageThread struct {
+	ID                 string  `json:"id"`
+	Contact            string  `json:"contact"`
+	IsRead             bool    `json:"is_read"`
+	LastMessageContent *string `json:"last_message_content"`
+}
+
+func requestJSON(
+	ctx context.Context,
+	t *testing.T,
+	method string,
+	path string,
+	apiKey string,
+	payload any,
+	expectedStatus int,
+	output any,
+) {
+	t.Helper()
+
+	var body io.Reader
+	if payload != nil {
+		encoded, err := json.Marshal(payload)
+		require.NoError(t, err)
+		body = bytes.NewReader(encoded)
+	}
+
+	request, err := http.NewRequestWithContext(ctx, method, apiBaseURL+path, body)
+	require.NoError(t, err)
+	request.Header.Set("x-api-key", apiKey)
+	request.Header.Set("Content-Type", "application/json")
+
+	response, err := http.DefaultClient.Do(request)
+	require.NoError(t, err)
+	defer response.Body.Close()
+
+	responseBody, err := io.ReadAll(response.Body)
+	require.NoError(t, err)
+	require.Equal(t, expectedStatus, response.StatusCode, "response: %s", string(responseBody))
+
+	if output != nil {
+		require.NoError(t, json.Unmarshal(responseBody, output))
+	}
+}
+
+func fetchMessageThreads(ctx context.Context, t *testing.T, owner string) []integrationMessageThread {
+	t.Helper()
+
+	var response struct {
+		Data []integrationMessageThread `json:"data"`
+	}
+	path := fmt.Sprintf(
+		"/v1/message-threads?owner=%s&skip=0&limit=20&is_archived=false",
+		url.QueryEscape(owner),
+	)
+	requestJSON(ctx, t, http.MethodGet, path, userAPIKey, nil, http.StatusOK, &response)
+	return response.Data
+}
+
+func waitForMessageThread(
+	ctx context.Context,
+	t *testing.T,
+	owner string,
+	contact string,
+	timeout time.Duration,
+	matches func(integrationMessageThread) bool,
+) integrationMessageThread {
+	t.Helper()
+
+	deadline := time.Now().Add(timeout)
+	for time.Now().Before(deadline) {
+		for _, thread := range fetchMessageThreads(ctx, t, owner) {
+			if thread.Contact == contact && matches(thread) {
+				return thread
+			}
+		}
+		time.Sleep(500 * time.Millisecond)
+	}
+
+	t.Fatalf("thread %s -> %s did not reach the expected state within %v", owner, contact, timeout)
+	return integrationMessageThread{}
+}
+
+func markMessageThreadRead(ctx context.Context, t *testing.T, threadID string) integrationMessageThread {
+	t.Helper()
+
+	var response struct {
+		Data integrationMessageThread `json:"data"`
+	}
+	requestJSON(
+		ctx,
+		t,
+		http.MethodPut,
+		"/v1/message-threads/"+threadID,
+		userAPIKey,
+		map[string]any{"is_read": true},
+		http.StatusOK,
+		&response,
+	)
+	return response.Data
+}
+
+func TestMessageThreadReadReceipts(t *testing.T) {
+	ctx := context.Background()
+	phone := setupPhone(ctx, t, 60)
+	contact := randomPhoneNumber()
+
+	requestJSON(
+		ctx,
+		t,
+		http.MethodPost,
+		"/v1/messages/receive",
+		phone.PhoneAPIKey,
+		map[string]any{
+			"from":      contact,
+			"to":        phone.PhoneNumber,
+			"content":   "Unread inbound message",
+			"encrypted": false,
+			"sim":       "SIM1",
+			"timestamp": time.Now().UTC().Format(time.RFC3339),
+		},
+		http.StatusOK,
+		nil,
+	)
+
+	thread := waitForMessageThread(ctx, t, phone.PhoneNumber, contact, 20*time.Second, func(thread integrationMessageThread) bool {
+		return !thread.IsRead
+	})
+	assert.False(t, thread.IsRead)
+
+	updated := markMessageThreadRead(ctx, t, thread.ID)
+	assert.True(t, updated.IsRead)
+	waitForMessageThread(ctx, t, phone.PhoneNumber, contact, 10*time.Second, func(thread integrationMessageThread) bool {
+		return thread.IsRead
+	})
+
+	requestJSON(
+		ctx,
+		t,
+		http.MethodPost,
+		"/v1/messages/calls/missed",
+		phone.PhoneAPIKey,
+		map[string]any{
+			"from":      contact,
+			"to":        phone.PhoneNumber,
+			"sim":       "SIM1",
+			"timestamp": time.Now().UTC().Format(time.RFC3339),
+		},
+		http.StatusOK,
+		nil,
+	)
+
+	thread = waitForMessageThread(ctx, t, phone.PhoneNumber, contact, 20*time.Second, func(thread integrationMessageThread) bool {
+		return !thread.IsRead &&
+			thread.LastMessageContent != nil &&
+			*thread.LastMessageContent == "Missed phone call"
+	})
+	assert.False(t, thread.IsRead)
+
+	outboundContent := "Outbound activity preserves unread"
+	client := newAPIClient()
+	_, response, err := client.Messages.Send(ctx, &httpsms.MessageSendParams{
+		From:    phone.PhoneNumber,
+		To:      contact,
+		Content: outboundContent,
+	})
+	require.NoError(t, err)
+	require.Equal(t, http.StatusOK, response.HTTPResponse.StatusCode)
+
+	thread = waitForMessageThread(ctx, t, phone.PhoneNumber, contact, 20*time.Second, func(thread integrationMessageThread) bool {
+		return thread.LastMessageContent != nil &&
+			*thread.LastMessageContent == outboundContent
+	})
+	assert.False(t, thread.IsRead, "outbound activity must not clear unread state")
+}