Skip to content

Send and receive SMS messages using your Android phone programmatically via a simple HTTP API

5.8 KB
Raw Blame
package handlers

import (
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"net/http/httptest"
	"testing"
	"time"

	"github.com/NdoleStudio/httpsms/pkg/entities"
	"github.com/NdoleStudio/httpsms/pkg/middlewares"
	"github.com/NdoleStudio/httpsms/pkg/repositories"
	"github.com/NdoleStudio/httpsms/pkg/services"
	"github.com/NdoleStudio/httpsms/pkg/telemetry"
	"github.com/NdoleStudio/httpsms/pkg/validators"
	"github.com/gofiber/fiber/v3"
	"github.com/google/uuid"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

type messageThreadHandlerIndexRepositoryStub struct {
	repositories.MessageThreadRepository
	threads    []entities.MessageThread
	unreadOnly bool
	limit      int
}

func (stub *messageThreadHandlerIndexRepositoryStub) Index(_ context.Context, _ entities.UserID, _ string, _ bool, unreadOnly bool, params repositories.IndexParams) (*[]entities.MessageThread, error) {
	stub.unreadOnly = unreadOnly
	stub.limit = params.Limit
	threads := make([]entities.MessageThread, len(stub.threads))
	copy(threads, stub.threads)
	start := min(params.Skip, len(threads))
	threads = threads[start:min(start+params.Limit, len(threads))]
	return &threads, nil
}

type messageThreadHandlerContactProviderStub struct {
	contacts map[string]*entities.Contact
	calls    int
}

func (stub *messageThreadHandlerContactProviderStub) GetContactMap(context.Context, entities.UserID, []string) (map[string]*entities.Contact, error) {
	stub.calls++
	return stub.contacts, nil
}

func TestMessageThreadHandlerIndex_ParsesContactsAndUnreadQuery(t *testing.T) {
	contact := &entities.Contact{ID: uuid.New(), Name: "Alice", PhoneNumbers: []string{"+18005550100"}}
	repository := &messageThreadHandlerIndexRepositoryStub{threads: []entities.MessageThread{{Contact: "+18005550100"}}}
	provider := &messageThreadHandlerContactProviderStub{contacts: map[string]*entities.Contact{"+18005550100": contact}}
	logger := &messageThreadHandlerNoopLogger{}
	tracer := telemetry.NewOtelLogger("test", logger)
	service := services.NewMessageThreadService(logger, tracer, repository, nil, nil, provider)
	handler := NewMessageThreadHandler(logger, tracer, validators.NewMessageThreadHandlerValidator(logger, tracer), service)

	app := fiber.New()
	app.Use(func(c fiber.Ctx) error {
		c.Locals(middlewares.ContextKeyAuthUserID, entities.AuthContext{ID: entities.UserID("user-id"), Email: "[email protected]"})
		return c.Next()
	})
	handler.RegisterRoutes(app)

	req := httptest.NewRequest(http.MethodGet, "/v1/message-threads?owner=%2B18005550199&contacts=true&unread_only=true", nil)
	resp, err := app.Test(req, fiber.TestConfig{Timeout: time.Second})

	require.NoError(t, err)
	require.Equal(t, http.StatusOK, resp.StatusCode)
	assert.Equal(t, 1, provider.calls)
	assert.True(t, repository.unreadOnly)

	var payload struct {
		Data []entities.MessageThread `json:"data"`
	}

	require.NoError(t, json.NewDecoder(resp.Body).Decode(&payload))
	require.Len(t, payload.Data, 1)
	require.NotNil(t, payload.Data[0].ContactDetails)
	assert.Equal(t, contact.ID, payload.Data[0].ContactDetails.ID)
	assert.Equal(t, "Alice", payload.Data[0].ContactDetails.Name)
}

func TestMessageThreadHandlerIndexRejectsInvalidUnreadFilter(t *testing.T) {
	repository := &messageThreadHandlerIndexRepositoryStub{}
	logger := &messageThreadHandlerNoopLogger{}
	tracer := telemetry.NewOtelLogger("test", logger)
	service := services.NewMessageThreadService(logger, tracer, repository, nil, nil, nil)
	handler := NewMessageThreadHandler(logger, tracer, validators.NewMessageThreadHandlerValidator(logger, tracer), service)
	app := fiber.New()
	app.Use(func(c fiber.Ctx) error {
		c.Locals(middlewares.ContextKeyAuthUserID, entities.AuthContext{ID: entities.UserID("user-id"), Email: "[email protected]"})
		return c.Next()
	})
	handler.RegisterRoutes(app)

	response, err := app.Test(httptest.NewRequest(http.MethodGet, "/v1/message-threads?owner=%2B18005550199&unread_only=invalid", nil))

	require.NoError(t, err)
	defer response.Body.Close()
	assert.Equal(t, http.StatusUnprocessableEntity, response.StatusCode)
}

func TestMessageThreadIndexUsesRequestedLimitWithoutLookAhead(t *testing.T) {
	for _, test := range []struct {
		name    string
		count   int
		wantLen int
		limit   int
	}{
		{name: "empty", count: 0, wantLen: 0, limit: 20},
		{name: "partial page", count: 19, wantLen: 19, limit: 20},
		{name: "exactly one page", count: 20, wantLen: 20, limit: 20},
		{name: "another page exists", count: 21, wantLen: 20, limit: 20},
		{name: "custom limit", count: 4, wantLen: 3, limit: 3},
	} {
		t.Run(test.name, func(t *testing.T) {
			repository := &messageThreadHandlerIndexRepositoryStub{threads: make([]entities.MessageThread, test.count)}
			logger := &messageThreadHandlerNoopLogger{}
			tracer := telemetry.NewOtelLogger("test", logger)
			service := services.NewMessageThreadService(logger, tracer, repository, nil, nil, nil)
			handler := NewMessageThreadHandler(logger, tracer, validators.NewMessageThreadHandlerValidator(logger, tracer), service)
			app := fiber.New()
			app.Use(func(c fiber.Ctx) error {
				c.Locals(middlewares.ContextKeyAuthUserID, entities.AuthContext{ID: entities.UserID("user-id"), Email: "[email protected]"})
				return c.Next()
			})
			handler.RegisterRoutes(app)

			response, err := app.Test(httptest.NewRequest(http.MethodGet, fmt.Sprintf("/v1/message-threads?owner=%%2B18005550199&limit=%d", test.limit), nil))

			require.NoError(t, err)
			defer response.Body.Close()
			require.Equal(t, http.StatusOK, response.StatusCode)
			var body map[string]json.RawMessage
			require.NoError(t, json.NewDecoder(response.Body).Decode(&body))
			var threads []entities.MessageThread
			require.NoError(t, json.Unmarshal(body["data"], &threads))
			assert.Len(t, threads, test.wantLen)
			assert.NotContains(t, body, "has_more")
			assert.Equal(t, test.limit, repository.limit)
		})
	}
}