882ac62433
- outboundimage: re-encode large PNG/JPEG screenshots as downscaled JPEG (1600px long edge, q82, transparency flattened onto white) before upload; undecodable, small, GIF/WebP payloads are published untouched - outboundimage: StableHashPublisher skips the upload when the content-addressed object already exists (ObjectStater); OSS store implements it via IsObjectExist - cmd/dobotai: DOBOTAI_OUTBOUND_IMAGE_REWRITE_TIMEOUT default 60s -> 180s; DOBOTAI_OUTBOUND_IMAGE_COMPRESS (on by default, off restores raw bytes)
189 lines
5.6 KiB
Go
189 lines
5.6 KiB
Go
package outboundimage
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"image"
|
|
"image/color"
|
|
"image/jpeg"
|
|
"image/png"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func pngFixture(t *testing.T, width, height int, alpha bool) []byte {
|
|
t.Helper()
|
|
source := image.NewRGBA(image.Rect(0, 0, width, height))
|
|
seed := uint32(12345)
|
|
for y := 0; y < height; y++ {
|
|
for x := 0; x < width; x++ {
|
|
// A pseudo-random pattern keeps the PNG as large as a real manual
|
|
// screenshot, so the size thresholds are exercised for real.
|
|
seed = seed*1664525 + 1013904223
|
|
alphaValue := uint8(0xff)
|
|
if alpha && x < width/2 {
|
|
alphaValue = 0x00
|
|
}
|
|
source.SetRGBA(x, y, color.RGBA{
|
|
R: uint8(seed >> 24),
|
|
G: uint8(seed >> 16),
|
|
B: uint8(seed >> 8),
|
|
A: alphaValue,
|
|
})
|
|
}
|
|
}
|
|
var encoded bytes.Buffer
|
|
if err := png.Encode(&encoded, source); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return encoded.Bytes()
|
|
}
|
|
|
|
func TestCompressImageDownscalesLargeScreenshotToSmallerJPEG(t *testing.T) {
|
|
original := pngFixture(t, 3200, 1800, false)
|
|
|
|
data, contentType, applied := CompressImage(original, "image/png")
|
|
if !applied {
|
|
t.Fatal("expected a large screenshot to be compressed")
|
|
}
|
|
if contentType != "image/jpeg" {
|
|
t.Fatalf("contentType=%q", contentType)
|
|
}
|
|
if len(data) >= len(original) {
|
|
t.Fatalf("compressed size=%d original=%d", len(data), len(original))
|
|
}
|
|
decoded, err := jpeg.Decode(bytes.NewReader(data))
|
|
if err != nil {
|
|
t.Fatalf("compressed payload is not a JPEG: %v", err)
|
|
}
|
|
if decoded.Bounds().Dx() != compressMaxEdge || decoded.Bounds().Dy() != compressMaxEdge*1800/3200 {
|
|
t.Fatalf("bounds=%v", decoded.Bounds())
|
|
}
|
|
}
|
|
|
|
func TestCompressImageFlattensTransparencyInsteadOfBlack(t *testing.T) {
|
|
original := pngFixture(t, 2000, 2000, true)
|
|
|
|
data, _, applied := CompressImage(original, "image/png")
|
|
if !applied {
|
|
t.Fatal("expected a transparent screenshot to be compressed")
|
|
}
|
|
decoded, err := jpeg.Decode(bytes.NewReader(data))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
red, green, blue, _ := decoded.At(10, 10).RGBA()
|
|
if red < 0xf000 || green < 0xf000 || blue < 0xf000 {
|
|
t.Fatalf("transparent area rendered as %v instead of white", []uint32{red, green, blue})
|
|
}
|
|
}
|
|
|
|
func TestCompressImageLeavesSmallOrUndecodablePayloadsUntouched(t *testing.T) {
|
|
small := pngFixture(t, 64, 64, false)
|
|
if len(small) >= compressMinBytes {
|
|
t.Fatalf("fixture is not small: %d", len(small))
|
|
}
|
|
for _, test := range []struct {
|
|
name string
|
|
data []byte
|
|
contentType string
|
|
}{
|
|
{name: "small", data: small, contentType: "image/png"},
|
|
{name: "not an image", data: bytes.Repeat([]byte("x"), compressMinBytes+1), contentType: "image/png"},
|
|
{name: "gif stays animated", data: bytes.Repeat([]byte("x"), compressMinBytes+1), contentType: "image/gif"},
|
|
{name: "text", data: bytes.Repeat([]byte("x"), compressMinBytes+1), contentType: "text/plain"},
|
|
} {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
data, contentType, applied := CompressImage(test.data, test.contentType)
|
|
if applied || contentType != test.contentType || !bytes.Equal(data, test.data) {
|
|
t.Fatalf("payload changed: applied=%v contentType=%q bytes=%d", applied, contentType, len(data))
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
type capturePublisher struct {
|
|
data []byte
|
|
contentType string
|
|
calls int
|
|
}
|
|
|
|
func (p *capturePublisher) Publish(_ context.Context, data []byte, contentType string) (string, error) {
|
|
p.calls++
|
|
p.data = append([]byte(nil), data...)
|
|
p.contentType = contentType
|
|
return "https://img.example/1.png", nil
|
|
}
|
|
|
|
type pngFetcher struct {
|
|
data []byte
|
|
}
|
|
|
|
func (f *pngFetcher) Fetch(_ context.Context, _ string) ([]byte, string, error) {
|
|
return f.data, "image/png", nil
|
|
}
|
|
|
|
func TestRewritePublishesCompressedScreenshots(t *testing.T) {
|
|
original := pngFixture(t, 3200, 1800, false)
|
|
reference := "resource://AbCdEfGhIjKlMnOpQrStUv"
|
|
input := "步骤一\n\n"
|
|
|
|
publisher := &capturePublisher{}
|
|
NewRewriter(&pngFetcher{data: original}, publisher, 5).Rewrite(context.Background(), input)
|
|
if publisher.calls != 1 || publisher.contentType != "image/jpeg" {
|
|
t.Fatalf("calls=%d contentType=%q", publisher.calls, publisher.contentType)
|
|
}
|
|
if len(publisher.data) >= len(original) {
|
|
t.Fatalf("published bytes=%d original=%d", len(publisher.data), len(original))
|
|
}
|
|
|
|
disabled := &capturePublisher{}
|
|
NewRewriter(&pngFetcher{data: original}, disabled, 5, WithImageCompression(false)).Rewrite(context.Background(), input)
|
|
if disabled.contentType != "image/png" || !bytes.Equal(disabled.data, original) {
|
|
t.Fatalf("compression opt-out changed the payload: contentType=%q bytes=%d", disabled.contentType, len(disabled.data))
|
|
}
|
|
}
|
|
|
|
func TestStableHashPublisherReusesExistingObject(t *testing.T) {
|
|
store := &existingObjectStore{}
|
|
publisher, err := NewStableHashPublisher(store, "dobotai/im-images", "https://img.example/i")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
first, err := publisher.Publish(context.Background(), []byte("same-image"), "image/jpeg")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if store.puts != 1 {
|
|
t.Fatalf("puts=%d", store.puts)
|
|
}
|
|
store.exists = true
|
|
second, err := publisher.Publish(context.Background(), []byte("same-image"), "image/jpeg")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if first != second {
|
|
t.Fatalf("url1=%q url2=%q", first, second)
|
|
}
|
|
if store.puts != 1 {
|
|
t.Fatalf("existing object was uploaded again: puts=%d", store.puts)
|
|
}
|
|
if !strings.HasPrefix(second, "https://img.example/i/") {
|
|
t.Fatalf("url=%q", second)
|
|
}
|
|
}
|
|
|
|
type existingObjectStore struct {
|
|
exists bool
|
|
puts int
|
|
}
|
|
|
|
func (s *existingObjectStore) Put(_ context.Context, _ string, _ []byte, _ string) error {
|
|
s.puts++
|
|
return nil
|
|
}
|
|
|
|
func (s *existingObjectStore) Exists(_ context.Context, _ string) (bool, error) {
|
|
return s.exists, nil
|
|
}
|