94 lines
2.5 KiB
Go
94 lines
2.5 KiB
Go
package attachment
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"errors"
|
|
"image"
|
|
"image/color"
|
|
"image/png"
|
|
"io"
|
|
"messenger/internal/platform/apperr"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func TestValidateFilename(t *testing.T) {
|
|
for _, name := range []string{"", " ", "../a.png", `a\b.jpg`, "a\x00b", "a\nb", strings.Repeat("я", 256)} {
|
|
if err := ValidateFilename(name); apperr.KindOf(err) != apperr.KindInvalid {
|
|
t.Errorf("%q: %v", name, err)
|
|
}
|
|
}
|
|
if err := ValidateFilename("фото 👋.png"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
type failingRead struct{ prefix []byte }
|
|
|
|
func (r *failingRead) Read(p []byte) (int, error) {
|
|
if len(r.prefix) > 0 {
|
|
n := copy(p, r.prefix)
|
|
r.prefix = r.prefix[n:]
|
|
return n, nil
|
|
}
|
|
return 0, errors.New("injected storage read outage")
|
|
}
|
|
|
|
type openedBlob struct {
|
|
Blobs
|
|
reader io.Reader
|
|
}
|
|
|
|
func (b openedBlob) Open(context.Context, string) (io.ReadCloser, error) {
|
|
return io.NopCloser(b.reader), nil
|
|
}
|
|
|
|
func TestStagingReadOutageIsUnavailableBeforeAndAfterHeader(t *testing.T) {
|
|
var pngData bytes.Buffer
|
|
if err := png.Encode(&pngData, image.NewRGBA(image.Rect(0, 0, 2, 2))); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, prefix := range [][]byte{nil, pngData.Bytes()[:33]} {
|
|
s := NewService(nil, openedBlob{reader: &failingRead{prefix: prefix}}, 0, 0)
|
|
err := s.validate(context.Background(), "staging/test", "image/png")
|
|
if apperr.KindOf(err) != apperr.KindUnavailable {
|
|
t.Fatalf("storage read error classified as %v: %v", apperr.KindOf(err), err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestValidateImageRejectsCorruptionAndLimitsPixelsBeforeDecode(t *testing.T) {
|
|
im := image.NewNRGBA(image.Rect(0, 0, 3, 2))
|
|
im.Set(1, 1, color.NRGBA{R: 200, A: 255})
|
|
var b bytes.Buffer
|
|
if err := png.Encode(&b, im); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, tc := range []struct {
|
|
name, mime string
|
|
data []byte
|
|
pixels int64
|
|
kind apperr.Kind
|
|
}{
|
|
{"valid", "image/png", b.Bytes(), 6, apperr.KindInternal},
|
|
{"spoof", "image/jpeg", b.Bytes(), 6, apperr.KindUnsupportedMedia},
|
|
{"truncated", "image/png", b.Bytes()[:len(b.Bytes())-20], 6, apperr.KindUnsupportedMedia},
|
|
{"pixels", "image/png", b.Bytes(), 5, apperr.KindPayloadTooLarge},
|
|
{"garbage", "image/png", []byte("not a picture"), 6, apperr.KindUnsupportedMedia},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
err := ValidateImage(bytes.NewReader(tc.data), tc.mime, tc.pixels)
|
|
if tc.name == "valid" {
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return
|
|
}
|
|
if err == nil || apperr.KindOf(err) != tc.kind {
|
|
t.Fatalf("got %v, want kind %v", err, tc.kind)
|
|
}
|
|
})
|
|
}
|
|
}
|