sneak
30d63e80dc
Implements format detection by checking file magic bytes for JPEG, PNG, GIF, WebP, AVIF, and SVG. Includes validation against declared Content-Type.
498 lines
12 KiB
Go
498 lines
12 KiB
Go
package imgcache
|
|
|
|
import (
|
|
"bytes"
|
|
"io"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func TestDetectFormat(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
data []byte
|
|
wantMIME MIMEType
|
|
wantErr error
|
|
}{
|
|
{
|
|
name: "JPEG",
|
|
data: append([]byte{0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46, 0x00, 0x01}, make([]byte, 100)...),
|
|
wantMIME: MIMETypeJPEG,
|
|
wantErr: nil,
|
|
},
|
|
{
|
|
name: "PNG",
|
|
data: append([]byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0x00, 0x00, 0x00, 0x0D}, make([]byte, 100)...),
|
|
wantMIME: MIMETypePNG,
|
|
wantErr: nil,
|
|
},
|
|
{
|
|
name: "GIF87a",
|
|
data: append([]byte{0x47, 0x49, 0x46, 0x38, 0x37, 0x61, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, make([]byte, 100)...),
|
|
wantMIME: MIMETypeGIF,
|
|
wantErr: nil,
|
|
},
|
|
{
|
|
name: "GIF89a",
|
|
data: append([]byte{0x47, 0x49, 0x46, 0x38, 0x39, 0x61, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, make([]byte, 100)...),
|
|
wantMIME: MIMETypeGIF,
|
|
wantErr: nil,
|
|
},
|
|
{
|
|
name: "WebP",
|
|
data: append([]byte{
|
|
0x52, 0x49, 0x46, 0x46, // RIFF
|
|
0x00, 0x00, 0x00, 0x00, // file size (placeholder)
|
|
0x57, 0x45, 0x42, 0x50, // WEBP
|
|
}, make([]byte, 100)...),
|
|
wantMIME: MIMETypeWebP,
|
|
wantErr: nil,
|
|
},
|
|
{
|
|
name: "AVIF",
|
|
data: append([]byte{
|
|
0x00, 0x00, 0x00, 0x1C, // box size
|
|
0x66, 0x74, 0x79, 0x70, // ftyp
|
|
0x61, 0x76, 0x69, 0x66, // avif brand
|
|
}, make([]byte, 100)...),
|
|
wantMIME: MIMETypeAVIF,
|
|
wantErr: nil,
|
|
},
|
|
{
|
|
name: "AVIF sequence",
|
|
data: append([]byte{
|
|
0x00, 0x00, 0x00, 0x1C, // box size
|
|
0x66, 0x74, 0x79, 0x70, // ftyp
|
|
0x61, 0x76, 0x69, 0x73, // avis brand
|
|
}, make([]byte, 100)...),
|
|
wantMIME: MIMETypeAVIF,
|
|
wantErr: nil,
|
|
},
|
|
{
|
|
name: "SVG with XML declaration",
|
|
data: []byte(`<?xml version="1.0"?><svg></svg>`),
|
|
wantMIME: MIMETypeSVG,
|
|
wantErr: nil,
|
|
},
|
|
{
|
|
name: "SVG without declaration",
|
|
data: []byte(`<svg xmlns="http://www.w3.org/2000/svg"></svg>`),
|
|
wantMIME: MIMETypeSVG,
|
|
wantErr: nil,
|
|
},
|
|
{
|
|
name: "SVG with whitespace",
|
|
data: []byte(` <?xml version="1.0"?><svg></svg>`),
|
|
wantMIME: MIMETypeSVG,
|
|
wantErr: nil,
|
|
},
|
|
{
|
|
name: "SVG with BOM",
|
|
data: append([]byte{0xEF, 0xBB, 0xBF}, []byte(`<svg></svg>`)...),
|
|
wantMIME: MIMETypeSVG,
|
|
wantErr: nil,
|
|
},
|
|
{
|
|
name: "unknown format",
|
|
data: []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
|
|
wantMIME: "",
|
|
wantErr: ErrUnknownFormat,
|
|
},
|
|
{
|
|
name: "too short",
|
|
data: []byte{0xFF, 0xD8},
|
|
wantMIME: "",
|
|
wantErr: ErrNotEnoughData,
|
|
},
|
|
{
|
|
name: "empty",
|
|
data: []byte{},
|
|
wantMIME: "",
|
|
wantErr: ErrNotEnoughData,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got, err := DetectFormat(tt.data)
|
|
|
|
if err != tt.wantErr {
|
|
t.Errorf("DetectFormat() error = %v, wantErr %v", err, tt.wantErr)
|
|
|
|
return
|
|
}
|
|
|
|
if got != tt.wantMIME {
|
|
t.Errorf("DetectFormat() = %v, want %v", got, tt.wantMIME)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestValidateMagicBytes(t *testing.T) {
|
|
jpegData := append([]byte{0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46, 0x00, 0x01}, make([]byte, 100)...)
|
|
pngData := append([]byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0x00, 0x00, 0x00, 0x0D}, make([]byte, 100)...)
|
|
|
|
tests := []struct {
|
|
name string
|
|
data []byte
|
|
declaredType string
|
|
wantErr error
|
|
}{
|
|
{
|
|
name: "matching JPEG",
|
|
data: jpegData,
|
|
declaredType: "image/jpeg",
|
|
wantErr: nil,
|
|
},
|
|
{
|
|
name: "matching JPEG with params",
|
|
data: jpegData,
|
|
declaredType: "image/jpeg; charset=utf-8",
|
|
wantErr: nil,
|
|
},
|
|
{
|
|
name: "matching PNG",
|
|
data: pngData,
|
|
declaredType: "image/png",
|
|
wantErr: nil,
|
|
},
|
|
{
|
|
name: "mismatched type",
|
|
data: jpegData,
|
|
declaredType: "image/png",
|
|
wantErr: ErrMagicByteMismatch,
|
|
},
|
|
{
|
|
name: "unknown data",
|
|
data: []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
|
|
declaredType: "image/jpeg",
|
|
wantErr: ErrUnknownFormat,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
err := ValidateMagicBytes(tt.data, tt.declaredType)
|
|
|
|
if err != tt.wantErr {
|
|
t.Errorf("ValidateMagicBytes() error = %v, wantErr %v", err, tt.wantErr)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestIsSupportedMIMEType(t *testing.T) {
|
|
tests := []struct {
|
|
mimeType string
|
|
want bool
|
|
}{
|
|
{"image/jpeg", true},
|
|
{"image/png", true},
|
|
{"image/webp", true},
|
|
{"image/gif", true},
|
|
{"image/avif", true},
|
|
{"image/svg+xml", true},
|
|
{"IMAGE/JPEG", true},
|
|
{"image/jpeg; charset=utf-8", true},
|
|
{"image/tiff", false},
|
|
{"image/bmp", false},
|
|
{"application/octet-stream", false},
|
|
{"text/plain", false},
|
|
{"", false},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.mimeType, func(t *testing.T) {
|
|
if got := IsSupportedMIMEType(tt.mimeType); got != tt.want {
|
|
t.Errorf("IsSupportedMIMEType(%q) = %v, want %v", tt.mimeType, got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestPeekAndValidate(t *testing.T) {
|
|
jpegData := append([]byte{0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46, 0x00, 0x01}, []byte("rest of jpeg data")...)
|
|
pngData := append([]byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0x00, 0x00, 0x00, 0x0D}, []byte("rest of png data")...)
|
|
|
|
tests := []struct {
|
|
name string
|
|
data []byte
|
|
declaredType string
|
|
wantErr bool
|
|
wantData []byte
|
|
}{
|
|
{
|
|
name: "valid JPEG",
|
|
data: jpegData,
|
|
declaredType: "image/jpeg",
|
|
wantErr: false,
|
|
wantData: jpegData,
|
|
},
|
|
{
|
|
name: "valid PNG",
|
|
data: pngData,
|
|
declaredType: "image/png",
|
|
wantErr: false,
|
|
wantData: pngData,
|
|
},
|
|
{
|
|
name: "mismatched type",
|
|
data: jpegData,
|
|
declaredType: "image/png",
|
|
wantErr: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
r := bytes.NewReader(tt.data)
|
|
result, err := PeekAndValidate(r, tt.declaredType)
|
|
|
|
if tt.wantErr {
|
|
if err == nil {
|
|
t.Error("PeekAndValidate() expected error, got nil")
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
if err != nil {
|
|
t.Errorf("PeekAndValidate() unexpected error = %v", err)
|
|
|
|
return
|
|
}
|
|
|
|
// Read all data from result reader
|
|
got, err := io.ReadAll(result)
|
|
if err != nil {
|
|
t.Errorf("Failed to read result: %v", err)
|
|
|
|
return
|
|
}
|
|
|
|
if !bytes.Equal(got, tt.wantData) {
|
|
t.Errorf("PeekAndValidate() data mismatch: got %d bytes, want %d bytes", len(got), len(tt.wantData))
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestMIMEToImageFormat(t *testing.T) {
|
|
tests := []struct {
|
|
mimeType string
|
|
wantFormat ImageFormat
|
|
wantOk bool
|
|
}{
|
|
{"image/jpeg", FormatJPEG, true},
|
|
{"image/png", FormatPNG, true},
|
|
{"image/webp", FormatWebP, true},
|
|
{"image/gif", FormatGIF, true},
|
|
{"image/avif", FormatAVIF, true},
|
|
{"image/svg+xml", "", false}, // SVG doesn't convert to ImageFormat
|
|
{"image/tiff", "", false},
|
|
{"text/plain", "", false},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.mimeType, func(t *testing.T) {
|
|
got, ok := MIMEToImageFormat(tt.mimeType)
|
|
|
|
if ok != tt.wantOk {
|
|
t.Errorf("MIMEToImageFormat(%q) ok = %v, want %v", tt.mimeType, ok, tt.wantOk)
|
|
}
|
|
|
|
if got != tt.wantFormat {
|
|
t.Errorf("MIMEToImageFormat(%q) = %v, want %v", tt.mimeType, got, tt.wantFormat)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestImageFormatToMIME(t *testing.T) {
|
|
tests := []struct {
|
|
format ImageFormat
|
|
wantMIME string
|
|
}{
|
|
{FormatJPEG, "image/jpeg"},
|
|
{FormatPNG, "image/png"},
|
|
{FormatWebP, "image/webp"},
|
|
{FormatGIF, "image/gif"},
|
|
{FormatAVIF, "image/avif"},
|
|
{FormatOriginal, "application/octet-stream"},
|
|
{"unknown", "application/octet-stream"},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(string(tt.format), func(t *testing.T) {
|
|
got := ImageFormatToMIME(tt.format)
|
|
|
|
if got != tt.wantMIME {
|
|
t.Errorf("ImageFormatToMIME(%q) = %v, want %v", tt.format, got, tt.wantMIME)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestNormalizeMIMEType(t *testing.T) {
|
|
tests := []struct {
|
|
input string
|
|
want string
|
|
}{
|
|
{"image/jpeg", "image/jpeg"},
|
|
{"IMAGE/JPEG", "image/jpeg"},
|
|
{"image/jpeg; charset=utf-8", "image/jpeg"},
|
|
{" image/jpeg ", "image/jpeg"},
|
|
{"image/jpeg; boundary=something", "image/jpeg"},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.input, func(t *testing.T) {
|
|
got := normalizeMIMEType(tt.input)
|
|
|
|
if got != tt.want {
|
|
t.Errorf("normalizeMIMEType(%q) = %q, want %q", tt.input, got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestDetectSVG(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
data string
|
|
want bool
|
|
}{
|
|
{"xml declaration", `<?xml version="1.0"?><svg></svg>`, true},
|
|
{"svg element", `<svg xmlns="http://www.w3.org/2000/svg"></svg>`, true},
|
|
{"doctype", `<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">`, true},
|
|
{"with whitespace", `
|
|
<?xml version="1.0"?><svg></svg>`, true},
|
|
{"uppercase", `<SVG></SVG>`, true},
|
|
{"not svg", `<html></html>`, false},
|
|
{"random text", `hello world`, false},
|
|
{"empty", ``, false},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got := detectSVG([]byte(tt.data))
|
|
|
|
if got != tt.want {
|
|
t.Errorf("detectSVG(%q) = %v, want %v", tt.data, got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSkipBOM(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
data []byte
|
|
want []byte
|
|
}{
|
|
{"with BOM", []byte{0xEF, 0xBB, 0xBF, 'h', 'e', 'l', 'l', 'o'}, []byte("hello")},
|
|
{"without BOM", []byte("hello"), []byte("hello")},
|
|
{"empty", []byte{}, []byte{}},
|
|
{"only BOM", []byte{0xEF, 0xBB, 0xBF}, []byte{}},
|
|
{"partial BOM", []byte{0xEF, 0xBB}, []byte{0xEF, 0xBB}},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got := skipBOM(tt.data)
|
|
|
|
if !bytes.Equal(got, tt.want) {
|
|
t.Errorf("skipBOM() = %v, want %v", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestRealWorldSVGPatterns(t *testing.T) {
|
|
// Test various real-world SVG patterns
|
|
svgPatterns := []string{
|
|
`<?xml version="1.0" encoding="UTF-8"?>
|
|
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">
|
|
<circle cx="50" cy="50" r="40"/>
|
|
</svg>`,
|
|
`<svg viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
|
|
<path d="M12 2L2 7l10 5 10-5-10-5z"/>
|
|
</svg>`,
|
|
`<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
|
|
<svg xmlns="http://www.w3.org/2000/svg">
|
|
</svg>`,
|
|
}
|
|
|
|
for i, pattern := range svgPatterns {
|
|
data := []byte(pattern)
|
|
if len(data) < MinMagicBytes {
|
|
// Pad short SVGs for detection
|
|
data = append(data, make([]byte, MinMagicBytes-len(data))...)
|
|
}
|
|
|
|
got, err := DetectFormat(data)
|
|
if err != nil {
|
|
t.Errorf("Pattern %d: DetectFormat() error = %v", i, err)
|
|
|
|
continue
|
|
}
|
|
|
|
if got != MIMETypeSVG {
|
|
t.Errorf("Pattern %d: DetectFormat() = %v, want %v", i, got, MIMETypeSVG)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDetectFormatRIFFNotWebP(t *testing.T) {
|
|
// RIFF container but not WebP (e.g., WAV file)
|
|
wavData := []byte{
|
|
0x52, 0x49, 0x46, 0x46, // RIFF
|
|
0x00, 0x00, 0x00, 0x00, // file size
|
|
0x57, 0x41, 0x56, 0x45, // WAVE (not WEBP)
|
|
}
|
|
|
|
_, err := DetectFormat(wavData)
|
|
if err != ErrUnknownFormat {
|
|
t.Errorf("DetectFormat(WAV) error = %v, want %v", err, ErrUnknownFormat)
|
|
}
|
|
}
|
|
|
|
func TestDetectFormatFtypNotAVIF(t *testing.T) {
|
|
// ftyp container but not AVIF (e.g., MP4)
|
|
mp4Data := []byte{
|
|
0x00, 0x00, 0x00, 0x1C, // box size
|
|
0x66, 0x74, 0x79, 0x70, // ftyp
|
|
0x69, 0x73, 0x6F, 0x6D, // isom brand (not avif)
|
|
}
|
|
|
|
_, err := DetectFormat(mp4Data)
|
|
if err != ErrUnknownFormat {
|
|
t.Errorf("DetectFormat(MP4) error = %v, want %v", err, ErrUnknownFormat)
|
|
}
|
|
}
|
|
|
|
func TestPeekAndValidatePreservesReader(t *testing.T) {
|
|
// Ensure that after PeekAndValidate, we can read the complete original content
|
|
originalContent := append(
|
|
[]byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0x00, 0x00, 0x00, 0x0D},
|
|
[]byte(strings.Repeat("PNG IDAT chunk data here ", 100))...,
|
|
)
|
|
|
|
r := bytes.NewReader(originalContent)
|
|
validated, err := PeekAndValidate(r, "image/png")
|
|
if err != nil {
|
|
t.Fatalf("PeekAndValidate() error = %v", err)
|
|
}
|
|
|
|
// Read everything from the validated reader
|
|
got, err := io.ReadAll(validated)
|
|
if err != nil {
|
|
t.Fatalf("io.ReadAll() error = %v", err)
|
|
}
|
|
|
|
if !bytes.Equal(got, originalContent) {
|
|
t.Errorf("Content mismatch: got %d bytes, want %d bytes", len(got), len(originalContent))
|
|
}
|
|
}
|