pixa/internal/imgcache/service_test.go

package imgcache

import (
	"context"
	"io"
	"testing"
	"time"
)

func TestService_Get_WhitelistedHost(t *testing.T) {
	svc, fixtures := SetupTestService(t)
	ctx := context.Background()

	req := &ImageRequest{
		SourceHost: fixtures.GoodHost,
		SourcePath: "/images/photo.jpg",
		Size:       Size{Width: 50, Height: 50},
		Format:     FormatJPEG,
		Quality:    85,
		FitMode:    FitCover,
	}

	resp, err := svc.Get(ctx, req)
	if err != nil {
		t.Fatalf("Get() error = %v", err)
	}
	defer resp.Content.Close()

	// Verify we got content
	data, err := io.ReadAll(resp.Content)
	if err != nil {
		t.Fatalf("failed to read response: %v", err)
	}

	if len(data) == 0 {
		t.Error("expected non-empty response")
	}

	if resp.ContentType != "image/jpeg" {
		t.Errorf("ContentType = %q, want %q", resp.ContentType, "image/jpeg")
	}
}

func TestService_Get_NonWhitelistedHost_NoSignature(t *testing.T) {
	svc, fixtures := SetupTestService(t, WithSigningKey("test-key"))

	req := &ImageRequest{
		SourceHost: fixtures.OtherHost,
		SourcePath: "/uploads/image.jpg",
		Size:       Size{Width: 50, Height: 50},
		Format:     FormatJPEG,
		Quality:    85,
		FitMode:    FitCover,
	}

	// Should fail validation - not whitelisted and no signature
	err := svc.ValidateRequest(req)
	if err == nil {
		t.Error("ValidateRequest() expected error for non-whitelisted host without signature")
	}
}

func TestService_Get_NonWhitelistedHost_ValidSignature(t *testing.T) {
	signingKey := "test-signing-key-12345"
	svc, fixtures := SetupTestService(t, WithSigningKey(signingKey))
	ctx := context.Background()

	req := &ImageRequest{
		SourceHost: fixtures.OtherHost,
		SourcePath: "/uploads/image.jpg",
		Size:       Size{Width: 50, Height: 50},
		Format:     FormatJPEG,
		Quality:    85,
		FitMode:    FitCover,
	}

	// Generate a valid signature
	signer := NewSigner(signingKey)
	req.Expires = time.Now().Add(time.Hour)
	req.Signature = signer.Sign(req)

	// Should pass validation
	err := svc.ValidateRequest(req)
	if err != nil {
		t.Errorf("ValidateRequest() error = %v", err)
	}

	// Should fetch successfully
	resp, err := svc.Get(ctx, req)
	if err != nil {
		t.Fatalf("Get() error = %v", err)
	}
	defer resp.Content.Close()

	data, err := io.ReadAll(resp.Content)
	if err != nil {
		t.Fatalf("failed to read response: %v", err)
	}

	if len(data) == 0 {
		t.Error("expected non-empty response")
	}
}

func TestService_Get_NonWhitelistedHost_ExpiredSignature(t *testing.T) {
	signingKey := "test-signing-key-12345"
	svc, fixtures := SetupTestService(t, WithSigningKey(signingKey))

	req := &ImageRequest{
		SourceHost: fixtures.OtherHost,
		SourcePath: "/uploads/image.jpg",
		Size:       Size{Width: 50, Height: 50},
		Format:     FormatJPEG,
		Quality:    85,
		FitMode:    FitCover,
	}

	// Generate an expired signature
	signer := NewSigner(signingKey)
	req.Expires = time.Now().Add(-time.Hour) // Already expired
	req.Signature = signer.Sign(req)

	// Should fail validation
	err := svc.ValidateRequest(req)
	if err == nil {
		t.Error("ValidateRequest() expected error for expired signature")
	}
}

func TestService_Get_NonWhitelistedHost_InvalidSignature(t *testing.T) {
	signingKey := "test-signing-key-12345"
	svc, fixtures := SetupTestService(t, WithSigningKey(signingKey))

	req := &ImageRequest{
		SourceHost: fixtures.OtherHost,
		SourcePath: "/uploads/image.jpg",
		Size:       Size{Width: 50, Height: 50},
		Format:     FormatJPEG,
		Quality:    85,
		FitMode:    FitCover,
	}

	// Set an invalid signature
	req.Signature = "invalid-signature"
	req.Expires = time.Now().Add(time.Hour)

	// Should fail validation
	err := svc.ValidateRequest(req)
	if err == nil {
		t.Error("ValidateRequest() expected error for invalid signature")
	}
}

// TestService_ValidateRequest_SignatureExactHostMatch verifies that
// ValidateRequest enforces exact host matching for signatures. A
// signature for one host must not verify for a different host, even
// if they share a domain suffix.
func TestService_ValidateRequest_SignatureExactHostMatch(t *testing.T) {
	signingKey := "test-signing-key-must-be-32-chars"
	svc, _ := SetupTestService(t,
		WithSigningKey(signingKey),
		WithNoWhitelist(),
	)

	signer := NewSigner(signingKey)

	// Sign a request for "cdn.example.com"
	signedReq := &ImageRequest{
		SourceHost: "cdn.example.com",
		SourcePath: "/photos/cat.jpg",
		Size:       Size{Width: 50, Height: 50},
		Format:     FormatJPEG,
		Quality:    85,
		FitMode:    FitCover,
		Expires:    time.Now().Add(time.Hour),
	}
	signedReq.Signature = signer.Sign(signedReq)

	// The original request should pass validation
	t.Run("exact host passes", func(t *testing.T) {
		err := svc.ValidateRequest(signedReq)
		if err != nil {
			t.Errorf("ValidateRequest() exact host failed: %v", err)
		}
	})

	// Try to reuse the signature with different hosts
	tests := []struct {
		name string
		host string
	}{
		{"parent domain", "example.com"},
		{"sibling subdomain", "images.example.com"},
		{"deeper subdomain", "a.cdn.example.com"},
		{"evil suffix domain", "cdn.example.com.evil.com"},
		{"prefixed host", "evilcdn.example.com"},
	}

	for _, tt := range tests {
		t.Run(tt.name+" rejected", func(t *testing.T) {
			req := &ImageRequest{
				SourceHost:  tt.host,
				SourcePath:  signedReq.SourcePath,
				SourceQuery: signedReq.SourceQuery,
				Size:        signedReq.Size,
				Format:      signedReq.Format,
				Quality:     signedReq.Quality,
				FitMode:     signedReq.FitMode,
				Expires:     signedReq.Expires,
				Signature:   signedReq.Signature,
			}

			err := svc.ValidateRequest(req)
			if err == nil {
				t.Errorf("ValidateRequest() should reject signature for host %q (signed for %q)",
					tt.host, signedReq.SourceHost)
			}
		})
	}
}

func TestService_Get_InvalidFile(t *testing.T) {
	svc, fixtures := SetupTestService(t)
	ctx := context.Background()

	req := &ImageRequest{
		SourceHost: fixtures.GoodHost,
		SourcePath: "/images/fake.jpg",
		Size:       Size{Width: 50, Height: 50},
		Format:     FormatJPEG,
		Quality:    85,
		FitMode:    FitCover,
	}

	// Should fail because magic bytes don't match
	_, err := svc.Get(ctx, req)
	if err == nil {
		t.Error("Get() expected error for invalid file")
	}
}

func TestService_Get_NotFound(t *testing.T) {
	svc, fixtures := SetupTestService(t)
	ctx := context.Background()

	req := &ImageRequest{
		SourceHost: fixtures.GoodHost,
		SourcePath: "/images/nonexistent.jpg",
		Size:       Size{Width: 50, Height: 50},
		Format:     FormatJPEG,
		Quality:    85,
		FitMode:    FitCover,
	}

	_, err := svc.Get(ctx, req)
	if err == nil {
		t.Error("Get() expected error for nonexistent file")
	}
}

func TestService_Get_FormatConversion(t *testing.T) {
	svc, fixtures := SetupTestService(t)
	ctx := context.Background()

	tests := []struct {
		name       string
		sourcePath string
		outFormat  ImageFormat
		wantMIME   string
	}{
		{
			name:       "JPEG to PNG",
			sourcePath: "/images/photo.jpg",
			outFormat:  FormatPNG,
			wantMIME:   "image/png",
		},
		{
			name:       "PNG to JPEG",
			sourcePath: "/images/logo.png",
			outFormat:  FormatJPEG,
			wantMIME:   "image/jpeg",
		},
		{
			name:       "GIF to PNG",
			sourcePath: "/images/animation.gif",
			outFormat:  FormatPNG,
			wantMIME:   "image/png",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			req := &ImageRequest{
				SourceHost: fixtures.GoodHost,
				SourcePath: tt.sourcePath,
				Size:       Size{Width: 50, Height: 50},
				Format:     tt.outFormat,
				Quality:    85,
				FitMode:    FitCover,
			}

			resp, err := svc.Get(ctx, req)
			if err != nil {
				t.Fatalf("Get() error = %v", err)
			}
			defer resp.Content.Close()

			if resp.ContentType != tt.wantMIME {
				t.Errorf("ContentType = %q, want %q", resp.ContentType, tt.wantMIME)
			}

			// Verify magic bytes match the expected format
			data, err := io.ReadAll(resp.Content)
			if err != nil {
				t.Fatalf("failed to read response: %v", err)
			}

			detectedMIME, err := DetectFormat(data)
			if err != nil {
				t.Fatalf("failed to detect format: %v", err)
			}

			expectedFormat, ok := MIMEToImageFormat(tt.wantMIME)
			if !ok {
				t.Fatalf("unknown format for MIME type: %s", tt.wantMIME)
			}

			detectedFormat, ok := MIMEToImageFormat(string(detectedMIME))
			if !ok {
				t.Fatalf("unknown format for detected MIME type: %s", detectedMIME)
			}

			if detectedFormat != expectedFormat {
				t.Errorf("detected format = %q, want %q", detectedFormat, expectedFormat)
			}
		})
	}
}

func TestService_Get_Caching(t *testing.T) {
	svc, fixtures := SetupTestService(t)
	ctx := context.Background()

	req := &ImageRequest{
		SourceHost: fixtures.GoodHost,
		SourcePath: "/images/photo.jpg",
		Size:       Size{Width: 50, Height: 50},
		Format:     FormatJPEG,
		Quality:    85,
		FitMode:    FitCover,
	}

	// First request - should be a cache miss
	resp1, err := svc.Get(ctx, req)
	if err != nil {
		t.Fatalf("Get() first request error = %v", err)
	}

	if resp1.CacheStatus != CacheMiss {
		t.Errorf("first request CacheStatus = %q, want %q", resp1.CacheStatus, CacheMiss)
	}

	data1, err := io.ReadAll(resp1.Content)
	if err != nil {
		t.Fatalf("failed to read first response: %v", err)
	}
	resp1.Content.Close()

	// Second request - should be a cache hit
	resp2, err := svc.Get(ctx, req)
	if err != nil {
		t.Fatalf("Get() second request error = %v", err)
	}

	if resp2.CacheStatus != CacheHit {
		t.Errorf("second request CacheStatus = %q, want %q", resp2.CacheStatus, CacheHit)
	}

	data2, err := io.ReadAll(resp2.Content)
	if err != nil {
		t.Fatalf("failed to read second response: %v", err)
	}
	resp2.Content.Close()

	// Content should be identical
	if len(data1) != len(data2) {
		t.Errorf("response sizes differ: %d vs %d", len(data1), len(data2))
	}
}

func TestService_Get_DifferentSizes(t *testing.T) {
	svc, fixtures := SetupTestService(t)
	ctx := context.Background()

	// Request same image at different sizes
	sizes := []Size{
		{Width: 25, Height: 25},
		{Width: 50, Height: 50},
		{Width: 75, Height: 75},
	}

	var responses [][]byte

	for _, size := range sizes {
		req := &ImageRequest{
			SourceHost: fixtures.GoodHost,
			SourcePath: "/images/photo.jpg",
			Size:       size,
			Format:     FormatJPEG,
			Quality:    85,
			FitMode:    FitCover,
		}

		resp, err := svc.Get(ctx, req)
		if err != nil {
			t.Fatalf("Get() error for size %v = %v", size, err)
		}

		data, err := io.ReadAll(resp.Content)
		if err != nil {
			t.Fatalf("failed to read response: %v", err)
		}
		resp.Content.Close()

		responses = append(responses, data)
	}

	// All responses should be different sizes (different cache entries)
	for i := 0; i < len(responses)-1; i++ {
		if len(responses[i]) == len(responses[i+1]) {
			// Not necessarily an error, but worth noting
			t.Logf("responses %d and %d have same size: %d bytes", i, i+1, len(responses[i]))
		}
	}
}

func TestService_ValidateRequest_NoSigningKey(t *testing.T) {
	// Service with no signing key - all non-whitelisted requests should fail
	svc, fixtures := SetupTestService(t, WithNoWhitelist())

	req := &ImageRequest{
		SourceHost: fixtures.OtherHost,
		SourcePath: "/uploads/image.jpg",
		Size:       Size{Width: 50, Height: 50},
		Format:     FormatJPEG,
		Quality:    85,
		FitMode:    FitCover,
	}

	err := svc.ValidateRequest(req)
	if err == nil {
		t.Error("ValidateRequest() expected error when no signing key and host not whitelisted")
	}
}

func TestService_Get_ContextCancellation(t *testing.T) {
	svc, fixtures := SetupTestService(t)

	ctx, cancel := context.WithCancel(context.Background())
	cancel() // Cancel immediately

	req := &ImageRequest{
		SourceHost: fixtures.GoodHost,
		SourcePath: "/images/photo.jpg",
		Size:       Size{Width: 50, Height: 50},
		Format:     FormatJPEG,
		Quality:    85,
		FitMode:    FitCover,
	}

	_, err := svc.Get(ctx, req)
	if err == nil {
		t.Error("Get() expected error for cancelled context")
	}
}

func TestService_Get_ReturnsETag(t *testing.T) {
	svc, fixtures := SetupTestService(t)
	ctx := context.Background()

	req := &ImageRequest{
		SourceHost: fixtures.GoodHost,
		SourcePath: "/images/photo.jpg",
		Size:       Size{Width: 50, Height: 50},
		Format:     FormatJPEG,
		Quality:    85,
		FitMode:    FitCover,
	}

	resp, err := svc.Get(ctx, req)
	if err != nil {
		t.Fatalf("Get() error = %v", err)
	}
	defer resp.Content.Close()

	// ETag should be set
	if resp.ETag == "" {
		t.Error("ETag should be set in response")
	}

	// ETag should be properly quoted
	if len(resp.ETag) < 2 || resp.ETag[0] != '"' || resp.ETag[len(resp.ETag)-1] != '"' {
		t.Errorf("ETag should be quoted, got %q", resp.ETag)
	}
}

func TestService_Get_ETagConsistency(t *testing.T) {
	svc, fixtures := SetupTestService(t)
	ctx := context.Background()

	req := &ImageRequest{
		SourceHost: fixtures.GoodHost,
		SourcePath: "/images/photo.jpg",
		Size:       Size{Width: 50, Height: 50},
		Format:     FormatJPEG,
		Quality:    85,
		FitMode:    FitCover,
	}

	// First request
	resp1, err := svc.Get(ctx, req)
	if err != nil {
		t.Fatalf("Get() first request error = %v", err)
	}
	etag1 := resp1.ETag
	resp1.Content.Close()

	// Second request (from cache)
	resp2, err := svc.Get(ctx, req)
	if err != nil {
		t.Fatalf("Get() second request error = %v", err)
	}
	etag2 := resp2.ETag
	resp2.Content.Close()

	// ETags should be identical for the same content
	if etag1 != etag2 {
		t.Errorf("ETags should match: %q != %q", etag1, etag2)
	}
}

func TestService_Get_DifferentETagsForDifferentContent(t *testing.T) {
	svc, fixtures := SetupTestService(t)
	ctx := context.Background()

	// Request same image at different sizes - should get different ETags
	req1 := &ImageRequest{
		SourceHost: fixtures.GoodHost,
		SourcePath: "/images/photo.jpg",
		Size:       Size{Width: 25, Height: 25},
		Format:     FormatJPEG,
		Quality:    85,
		FitMode:    FitCover,
	}

	req2 := &ImageRequest{
		SourceHost: fixtures.GoodHost,
		SourcePath: "/images/photo.jpg",
		Size:       Size{Width: 50, Height: 50},
		Format:     FormatJPEG,
		Quality:    85,
		FitMode:    FitCover,
	}

	resp1, err := svc.Get(ctx, req1)
	if err != nil {
		t.Fatalf("Get() first request error = %v", err)
	}
	etag1 := resp1.ETag
	resp1.Content.Close()

	resp2, err := svc.Get(ctx, req2)
	if err != nil {
		t.Fatalf("Get() second request error = %v", err)
	}
	etag2 := resp2.ETag
	resp2.Content.Close()

	// ETags should be different for different content
	if etag1 == etag2 {
		t.Error("ETags should differ for different sizes")
	}
}