Files
mtusi2026lab5/internal/attachment/validation_test.go
T

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)
}
})
}
}