forked from mtusi2026/mtusi2026lab6
108 lines
3.3 KiB
Go
108 lines
3.3 KiB
Go
package imageprocessor
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
|
|
"image"
|
|
"image/color"
|
|
"image/png"
|
|
"testing"
|
|
|
|
_ "golang.org/x/image/webp"
|
|
|
|
"gitea.privcloud.tech/vlad_marlo/mtusi2026lab6/internal/pipeline"
|
|
)
|
|
|
|
// sourcePNG creates a transparent synthetic source with controlled dimensions.
|
|
func sourcePNG(t *testing.T, width, height int) []byte {
|
|
t.Helper()
|
|
pic := image.NewNRGBA(image.Rect(0, 0, width, height))
|
|
pic.Set(0, 0, color.NRGBA{R: 255, A: 128})
|
|
var data bytes.Buffer
|
|
if err := png.Encode(&data, pic); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return data.Bytes()
|
|
}
|
|
|
|
// TestVariantsDimensions verifies real JPEG/WebP output and white transparency composition.
|
|
func TestVariantsDimensions(t *testing.T) {
|
|
for _, size := range []struct {
|
|
width int
|
|
height int
|
|
thumbWidth int
|
|
thumbHeight int
|
|
}{{320, 200, 256, 160}, {16, 8, 16, 8}, {200, 320, 160, 256}, {1600, 800, 256, 128}} {
|
|
t.Run(fmt.Sprintf("%dx%d", size.width, size.height), func(t *testing.T) {
|
|
processor, err := New()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
outputs, err := processor.Process(t.Context(), sourcePNG(t, size.width, size.height))
|
|
if err != nil || len(outputs) != 3 {
|
|
t.Fatalf("variants: %v", err)
|
|
}
|
|
for _, out := range outputs {
|
|
decoded, format, err := image.Decode(bytes.NewReader(out.Bytes))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if decoded.Bounds().Dx() != out.Metadata.Width || decoded.Bounds().Dy() != out.Metadata.Height {
|
|
t.Fatal("metadata dimensions differ")
|
|
}
|
|
if out.Metadata.Name == "thumbnail" && (out.Metadata.Width != size.thumbWidth || out.Metadata.Height != size.thumbHeight || format != "jpeg") {
|
|
t.Fatal("thumbnail contract")
|
|
}
|
|
if out.Metadata.Name == "crop" && (out.Metadata.Width != 128 || out.Metadata.Height != 128 || format != "jpeg") {
|
|
t.Fatal("crop contract")
|
|
}
|
|
if out.Metadata.Name == "optimized" && (max(out.Metadata.Width, out.Metadata.Height) > 1280 || format != "webp") {
|
|
t.Fatal("optimized contract")
|
|
}
|
|
r, g, b, _ := decoded.At(decoded.Bounds().Max.X-1, decoded.Bounds().Max.Y-1).RGBA()
|
|
if min(r, g, b) < 60000 {
|
|
t.Fatal("alpha not composed on white")
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestProcessorInvalidImage verifies malformed bytes are a permanent safe error.
|
|
func TestProcessorInvalidImage(t *testing.T) {
|
|
processor := &Processor{webp: "unused"}
|
|
_, err := processor.Process(t.Context(), []byte("not an image"))
|
|
if !errors.Is(err, pipeline.ErrInvalidImage) {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
// TestProcessorCancellation prevents decode after an expired job deadline.
|
|
func TestProcessorCancellation(t *testing.T) {
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
cancel()
|
|
_, err := (&Processor{}).Process(ctx, sourcePNG(t, 10, 10))
|
|
if !errors.Is(err, context.Canceled) {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
// TestProcessorEncoderFailure verifies a missing encoder is not a successful variant set.
|
|
func TestProcessorEncoderFailure(t *testing.T) {
|
|
_, err := (&Processor{webp: "/missing-encoder"}).Process(t.Context(), sourcePNG(t, 10, 10))
|
|
if err == nil {
|
|
t.Fatal("missing encoder accepted")
|
|
}
|
|
}
|
|
|
|
// TestProcessorRequiresEncoder validates the deployment dependency at startup.
|
|
func TestProcessorRequiresEncoder(t *testing.T) {
|
|
t.Setenv("PATH", t.TempDir())
|
|
if _, err := New(); err == nil {
|
|
t.Fatal("missing cwebp accepted")
|
|
}
|
|
}
|