clawbot
f149813c7e
check / check (push) Successful in 13s
A fit in the URL with an empty value (fit=) was treated as missing, so it was served as cover and verified against a signature made for cover. It is now a 400 naming fit, the same rule the route applies to an empty q. It is checked before the existing fit-mode check, which takes an empty fit as missing; any other value still goes through that check unchanged. Only a fit missing from the URL is cover. Model: opus-5-5
397 lines
9.8 KiB
Go
397 lines
9.8 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"
|
|
"sneak.berlin/go/pixa/internal/database"
|
|
"sneak.berlin/go/pixa/internal/httpfetcher"
|
|
"sneak.berlin/go/pixa/internal/imgcache"
|
|
)
|
|
|
|
// testFixtures contains test data.
|
|
type testFixtures struct {
|
|
handler *Handlers
|
|
service *imgcache.Service
|
|
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,
|
|
CacheTTL: time.Hour,
|
|
NegativeTTL: 5 * time.Minute,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("failed to create cache: %v", err)
|
|
}
|
|
|
|
svc, err := imgcache.NewService(&imgcache.ServiceConfig{
|
|
Cache: cache,
|
|
Fetcher: newMockFetcher(mockFS),
|
|
SigningKey: "test-signing-key-must-be-32-chars",
|
|
Allowlist: []string{goodHost},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("failed to create service: %v", err)
|
|
}
|
|
|
|
h := &Handlers{
|
|
imgSvc: svc,
|
|
log: slog.Default(),
|
|
}
|
|
|
|
return &testFixtures{
|
|
handler: h,
|
|
service: svc,
|
|
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)
|
|
}
|
|
}
|