sneak
6d9631a8fc
check / check (push) Waiting to run
The new package internal/providers builds the cache, the fetcher, the processor, the image service, the session manager and the encrypted URL generator from the config. pixad's fx graph provides them with providers.Constructors(), and handlers.New receives them built. The server tests build the same graph, with only the fetcher's dial function replaced. database.New opens the database, so these parts can read it while fx builds them; the cache's stop hook still runs before the database's. Each setting's default is declared in internal/config, and internal/providers works out the default cache_max_bytes. The cache's MaxBytes is the one value for the disk cache limit, and 0 turns the disk cache off. The fetcher and the processor take explicit values. Model: opus-5-5
402 lines
10 KiB
Go
402 lines
10 KiB
Go
package handlers
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"database/sql"
|
|
"encoding/json"
|
|
"image"
|
|
"image/color"
|
|
"image/jpeg"
|
|
"io"
|
|
"io/fs"
|
|
"log/slog"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"testing"
|
|
"testing/fstest"
|
|
"time"
|
|
|
|
"github.com/go-chi/chi/v5"
|
|
"github.com/prometheus/client_golang/prometheus"
|
|
"sneak.berlin/go/pixa/internal/database"
|
|
"sneak.berlin/go/pixa/internal/httpfetcher"
|
|
"sneak.berlin/go/pixa/internal/imageprocessor"
|
|
"sneak.berlin/go/pixa/internal/imgcache"
|
|
)
|
|
|
|
// testFixtures contains test data.
|
|
type testFixtures struct {
|
|
handler *Handlers
|
|
goodHost string
|
|
}
|
|
|
|
func setupTestHandler(t *testing.T) *testFixtures {
|
|
t.Helper()
|
|
|
|
goodHost := "goodhost.example.com"
|
|
|
|
// Generate test JPEG
|
|
jpegData := generateTestJPEG(t, 100, 100, color.RGBA{255, 0, 0, 255})
|
|
|
|
mockFS := fstest.MapFS{
|
|
goodHost + "/images/photo.jpg": &fstest.MapFile{Data: jpegData},
|
|
}
|
|
|
|
tmpDir := t.TempDir()
|
|
db := setupTestDB(t)
|
|
|
|
cache, err := imgcache.NewCache(db, imgcache.CacheConfig{
|
|
StateDir: tmpDir,
|
|
NegativeTTL: 5 * time.Minute,
|
|
MaxBytes: 1 << 30,
|
|
}, prometheus.NewRegistry())
|
|
if err != nil {
|
|
t.Fatalf("failed to create cache: %v", err)
|
|
}
|
|
|
|
svc, err := imgcache.NewService(&imgcache.ServiceConfig{
|
|
Cache: cache,
|
|
Fetcher: newMockFetcher(mockFS),
|
|
Processor: imageprocessor.New(imageprocessor.Params{
|
|
MaxInputBytes: 50 << 20,
|
|
MaxConcurrentProcessing: 2,
|
|
}),
|
|
SigningKey: "test-signing-key-must-be-32-chars",
|
|
Allowlist: []string{goodHost},
|
|
MaxResponseSize: 50 << 20,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("failed to create service: %v", err)
|
|
}
|
|
|
|
h := &Handlers{
|
|
imgSvc: svc,
|
|
log: slog.Default(),
|
|
}
|
|
|
|
return &testFixtures{
|
|
handler: h,
|
|
goodHost: goodHost,
|
|
}
|
|
}
|
|
|
|
func setupTestDB(t *testing.T) *sql.DB {
|
|
t.Helper()
|
|
|
|
db, err := sql.Open("sqlite", ":memory:")
|
|
if err != nil {
|
|
t.Fatalf("failed to open test db: %v", err)
|
|
}
|
|
|
|
err = database.ApplyMigrations(context.Background(), db, nil)
|
|
if err != nil {
|
|
t.Fatalf("failed to apply migrations: %v", err)
|
|
}
|
|
|
|
return db
|
|
}
|
|
|
|
func generateTestJPEG(t *testing.T, width, height int, c color.Color) []byte {
|
|
t.Helper()
|
|
|
|
img := image.NewRGBA(image.Rect(0, 0, width, height))
|
|
for y := range height {
|
|
for x := range width {
|
|
img.Set(x, y, c)
|
|
}
|
|
}
|
|
|
|
var buf bytes.Buffer
|
|
|
|
err := jpeg.Encode(&buf, img, &jpeg.Options{Quality: 85})
|
|
if err != nil {
|
|
t.Fatalf("failed to encode test JPEG: %v", err)
|
|
}
|
|
|
|
return buf.Bytes()
|
|
}
|
|
|
|
// mockFetcher fetches from a mock filesystem.
|
|
type mockFetcher struct {
|
|
fs fs.FS
|
|
}
|
|
|
|
func newMockFetcher(fs fs.FS) *mockFetcher {
|
|
return &mockFetcher{fs: fs}
|
|
}
|
|
|
|
func (f *mockFetcher) Fetch(
|
|
_ context.Context, url string,
|
|
) (*httpfetcher.FetchResult, error) {
|
|
// Remove https:// prefix
|
|
path := url[8:] // Remove "https://"
|
|
|
|
data, err := fs.ReadFile(f.fs, path)
|
|
if err != nil {
|
|
return nil, httpfetcher.ErrUpstreamError
|
|
}
|
|
|
|
return &httpfetcher.FetchResult{
|
|
Content: io.NopCloser(bytes.NewReader(data)),
|
|
ContentLength: int64(len(data)),
|
|
ContentType: "image/jpeg",
|
|
}, nil
|
|
}
|
|
|
|
func TestHandleImage_HEAD_ReturnsHeadersOnly(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
fix := setupTestHandler(t)
|
|
|
|
// Create a chi router to properly handle wildcards
|
|
r := chi.NewRouter()
|
|
r.Head("/v1/image/*", fix.handler.HandleImage())
|
|
|
|
req := httptest.NewRequestWithContext(t.Context(), http.MethodHead,
|
|
"/v1/image/"+fix.goodHost+"/images/photo.jpg/50x50.jpeg", nil)
|
|
rec := httptest.NewRecorder()
|
|
|
|
r.ServeHTTP(rec, req)
|
|
|
|
// Should return 200 OK
|
|
if rec.Code != http.StatusOK {
|
|
t.Errorf("HEAD request status = %d, want %d", rec.Code, http.StatusOK)
|
|
}
|
|
|
|
// Should have Content-Type header
|
|
if ct := rec.Header().Get("Content-Type"); ct == "" {
|
|
t.Error("HEAD response should have Content-Type header")
|
|
}
|
|
|
|
// Should have Content-Length header
|
|
if cl := rec.Header().Get("Content-Length"); cl == "" {
|
|
t.Error("HEAD response should have Content-Length header")
|
|
}
|
|
|
|
// Body should be empty for HEAD request
|
|
if rec.Body.Len() != 0 {
|
|
t.Errorf("HEAD response body should be empty, got %d bytes", rec.Body.Len())
|
|
}
|
|
}
|
|
|
|
func TestHandleImage_ConditionalRequest_IfNoneMatch_Returns304(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
fix := setupTestHandler(t)
|
|
|
|
r := chi.NewRouter()
|
|
r.Get("/v1/image/*", fix.handler.HandleImage())
|
|
|
|
// First request to get the ETag
|
|
req1 := httptest.NewRequestWithContext(t.Context(), http.MethodGet,
|
|
"/v1/image/"+fix.goodHost+"/images/photo.jpg/50x50.jpeg", nil)
|
|
rec1 := httptest.NewRecorder()
|
|
|
|
r.ServeHTTP(rec1, req1)
|
|
|
|
if rec1.Code != http.StatusOK {
|
|
t.Fatalf("First request status = %d, want %d", rec1.Code, http.StatusOK)
|
|
}
|
|
|
|
etag := rec1.Header().Get("ETag")
|
|
if etag == "" {
|
|
t.Fatal("Response should have ETag header")
|
|
}
|
|
|
|
// Second request with If-None-Match header
|
|
req2 := httptest.NewRequestWithContext(t.Context(), http.MethodGet,
|
|
"/v1/image/"+fix.goodHost+"/images/photo.jpg/50x50.jpeg", nil)
|
|
req2.Header.Set("If-None-Match", etag)
|
|
|
|
rec2 := httptest.NewRecorder()
|
|
|
|
r.ServeHTTP(rec2, req2)
|
|
|
|
// Should return 304 Not Modified
|
|
if rec2.Code != http.StatusNotModified {
|
|
t.Errorf("Conditional request status = %d, want %d",
|
|
rec2.Code, http.StatusNotModified)
|
|
}
|
|
|
|
// Body should be empty for 304 response
|
|
if rec2.Body.Len() != 0 {
|
|
t.Errorf("304 response body should be empty, got %d bytes", rec2.Body.Len())
|
|
}
|
|
}
|
|
|
|
func TestHandleImage_ConditionalRequest_IfNoneMatch_DifferentETag(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
fix := setupTestHandler(t)
|
|
|
|
r := chi.NewRouter()
|
|
r.Get("/v1/image/*", fix.handler.HandleImage())
|
|
|
|
// Request with non-matching ETag
|
|
req := httptest.NewRequestWithContext(t.Context(), http.MethodGet,
|
|
"/v1/image/"+fix.goodHost+"/images/photo.jpg/50x50.jpeg", nil)
|
|
req.Header.Set("If-None-Match", `"different-etag"`)
|
|
|
|
rec := httptest.NewRecorder()
|
|
|
|
r.ServeHTTP(rec, req)
|
|
|
|
// Should return 200 OK with full response
|
|
if rec.Code != http.StatusOK {
|
|
t.Errorf("Request with non-matching ETag status = %d, want %d",
|
|
rec.Code, http.StatusOK)
|
|
}
|
|
|
|
// Body should not be empty
|
|
if rec.Body.Len() == 0 {
|
|
t.Error("Response body should not be empty for non-matching ETag")
|
|
}
|
|
}
|
|
|
|
func TestHandleImage_ETagHeader(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
fix := setupTestHandler(t)
|
|
|
|
r := chi.NewRouter()
|
|
r.Get("/v1/image/*", fix.handler.HandleImage())
|
|
|
|
req := httptest.NewRequestWithContext(t.Context(), http.MethodGet,
|
|
"/v1/image/"+fix.goodHost+"/images/photo.jpg/50x50.jpeg", nil)
|
|
rec := httptest.NewRecorder()
|
|
|
|
r.ServeHTTP(rec, req)
|
|
|
|
if rec.Code != http.StatusOK {
|
|
t.Fatalf("Request status = %d, want %d", rec.Code, http.StatusOK)
|
|
}
|
|
|
|
etag := rec.Header().Get("ETag")
|
|
if etag == "" {
|
|
t.Error("Response should have ETag header")
|
|
}
|
|
|
|
// ETag should be quoted
|
|
if len(etag) < 2 || etag[0] != '"' || etag[len(etag)-1] != '"' {
|
|
t.Errorf("ETag should be quoted, got %q", etag)
|
|
}
|
|
}
|
|
|
|
// TestHandleImage_InvalidFitMode_Returns400 verifies that the plain image
|
|
// route rejects an unrecognized fit mode with 400.
|
|
func TestHandleImage_InvalidFitMode_Returns400(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
fix := setupTestHandler(t)
|
|
|
|
status := getImage(t, fix,
|
|
"/v1/image/"+fix.goodHost+"/images/photo.jpg/50x50.jpeg?fit=bogus")
|
|
|
|
if status != http.StatusBadRequest {
|
|
t.Fatalf("status = %d, want %d", status, http.StatusBadRequest)
|
|
}
|
|
}
|
|
|
|
// TestHandleImage_InvalidQuery_Returns400 verifies that the plain image route
|
|
// answers a q that is not a whole number from 1 to 100, an empty one
|
|
// included, with 400 naming q and the value, a parameter given more than once
|
|
// with 400 naming it, and a query string that cannot be decoded with 400
|
|
// showing it, instead of serving the image at the default quality 85 or at
|
|
// the first value given.
|
|
func TestHandleImage_InvalidQuery_Returns400(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
tests := []struct {
|
|
query, wantError string
|
|
}{
|
|
{"q=banana", `invalid q: not a number, got "banana"`},
|
|
{"q=0", `invalid q: must be from 1 to 100, got "0"`},
|
|
{"q=101", `invalid q: must be from 1 to 100, got "101"`},
|
|
{"q=", `invalid q: not a number, got ""`},
|
|
{"q=80&q=500", `invalid q: given more than once`},
|
|
{"q=80&q=", `invalid q: given more than once`},
|
|
{"fit=cover&fit=contain", `invalid fit: given more than once`},
|
|
{"q=80%", `invalid query string "q=80%": invalid URL escape "%"`},
|
|
{
|
|
"q=50;fit=contain",
|
|
`invalid query string "q=50;fit=contain": ` +
|
|
`invalid semicolon separator in query`,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.query, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
fix := setupTestHandler(t)
|
|
|
|
r := chi.NewRouter()
|
|
r.Get("/v1/image/*", fix.handler.HandleImage())
|
|
|
|
req := httptest.NewRequestWithContext(t.Context(), http.MethodGet,
|
|
"/v1/image/"+fix.goodHost+"/images/photo.jpg/50x50.jpeg?"+tt.query, nil)
|
|
rec := httptest.NewRecorder()
|
|
|
|
r.ServeHTTP(rec, req)
|
|
|
|
if rec.Code != http.StatusBadRequest {
|
|
t.Fatalf("status = %d, want %d", rec.Code, http.StatusBadRequest)
|
|
}
|
|
|
|
t.Logf("GET %s: %d %s", req.URL, rec.Code, rec.Body)
|
|
|
|
var body struct {
|
|
Error string `json:"error"`
|
|
}
|
|
|
|
err := json.NewDecoder(rec.Body).Decode(&body)
|
|
if err != nil {
|
|
t.Fatalf("decoding response body: %v", err)
|
|
}
|
|
|
|
if body.Error != tt.wantError {
|
|
t.Errorf("error = %q, want %q", body.Error, tt.wantError)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestHandleImage_EmptyFit_Returns400 verifies that the plain image route
|
|
// answers a fit that is in the URL but empty with 400 naming fit, instead of
|
|
// serving the image as cover. Only a fit missing from the URL means cover.
|
|
func TestHandleImage_EmptyFit_Returns400(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
fix := setupTestHandler(t)
|
|
|
|
r := chi.NewRouter()
|
|
r.Get("/v1/image/*", fix.handler.HandleImage())
|
|
|
|
req := httptest.NewRequestWithContext(t.Context(), http.MethodGet,
|
|
"/v1/image/"+fix.goodHost+"/images/photo.jpg/50x50.jpeg?fit=", nil)
|
|
rec := httptest.NewRecorder()
|
|
|
|
r.ServeHTTP(rec, req)
|
|
|
|
if rec.Code != http.StatusBadRequest {
|
|
t.Fatalf("status = %d, want %d", rec.Code, http.StatusBadRequest)
|
|
}
|
|
|
|
t.Logf("GET %s: %d %s", req.URL, rec.Code, rec.Body)
|
|
|
|
var body struct {
|
|
Error string `json:"error"`
|
|
}
|
|
|
|
err := json.NewDecoder(rec.Body).Decode(&body)
|
|
if err != nil {
|
|
t.Fatalf("decoding response body: %v", err)
|
|
}
|
|
|
|
wantError := `invalid fit: not a fit mode, got ""`
|
|
if body.Error != wantError {
|
|
t.Errorf("error = %q, want %q", body.Error, wantError)
|
|
}
|
|
}
|