146 lines
4.1 KiB
Go
146 lines
4.1 KiB
Go
package attachment
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"errors"
|
|
"image"
|
|
"image/color"
|
|
"image/png"
|
|
"io"
|
|
"os"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/google/uuid"
|
|
|
|
"messenger/internal/platform/apperr"
|
|
)
|
|
|
|
type chatMember struct {
|
|
chatID, userID uuid.UUID
|
|
}
|
|
|
|
func (m chatMember) IsMember(_ context.Context, chatID, userID uuid.UUID) (bool, error) {
|
|
return chatID == m.chatID && userID == m.userID, nil
|
|
}
|
|
|
|
func TestUploadWithoutStoragePreservesChatAccessCheck(t *testing.T) {
|
|
member := chatMember{chatID: uuid.New(), userID: uuid.New()}
|
|
s := NewService(nil, member, nil, Config{})
|
|
input := UploadInput{ChatID: member.chatID, Filename: "photo.png", MIMEType: "image/png", SizeBytes: 4}
|
|
for _, tc := range []struct {
|
|
name string
|
|
actor uuid.UUID
|
|
kind apperr.Kind
|
|
}{
|
|
{name: "member", actor: member.userID, kind: apperr.KindUnavailable},
|
|
{name: "outsider", actor: uuid.New(), kind: apperr.KindNotFound},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
_, err := s.Upload(context.Background(), tc.actor, input, strings.NewReader("data"))
|
|
if apperr.KindOf(err) != tc.kind {
|
|
t.Fatalf("got %v, want %v", err, tc.kind)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
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) {
|
|
if reader, ok := b.reader.(io.ReadCloser); ok {
|
|
return reader, nil
|
|
}
|
|
return io.NopCloser(b.reader), nil
|
|
}
|
|
|
|
type closeErrorBody struct{ io.Reader }
|
|
|
|
func (closeErrorBody) Close() error { return errors.New("injected close failure") }
|
|
|
|
func TestStagingCloseFailurePreventsPublication(t *testing.T) {
|
|
data, err := os.ReadFile("../../tests/fixtures/sample.png")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
blobs := openedBlob{reader: closeErrorBody{Reader: bytes.NewReader(data)}}
|
|
s := NewService(nil, nil, blobs, Config{})
|
|
if err := s.validate(context.Background(), "staging/test", "image/png"); apperr.KindOf(err) != apperr.KindUnavailable {
|
|
t.Fatalf("close failure classified as %v", err)
|
|
}
|
|
}
|
|
|
|
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, nil, openedBlob{reader: &failingRead{prefix: prefix}}, Config{})
|
|
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)
|
|
}
|
|
})
|
|
}
|
|
}
|