| @@ -0,0 +1,287 @@ |
| 1 | + | package hints |
| 2 | + | |
| 3 | + | import ( |
| 4 | + | "context" |
| 5 | + | "encoding/json" |
| 6 | + | "errors" |
| 7 | + | "fmt" |
| 8 | + | "image" |
| 9 | + | "image/draw" |
| 10 | + | _ "image/png" |
| 11 | + | "os" |
| 12 | + | "path/filepath" |
| 13 | + | "strings" |
| 14 | + | "testing" |
| 15 | + | "time" |
| 16 | + | |
| 17 | + | "github.com/stretchr/testify/require" |
| 18 | + | |
| 19 | + | "github.com/bnema/neferwl/internal/ports" |
| 20 | + | ) |
| 21 | + | |
| 22 | + | type harness struct { |
| 23 | + | requests chan ports.HintScanRequest |
| 24 | + | captures chan ports.CaptureRequest |
| 25 | + | captured chan ports.CaptureDone |
| 26 | + | results chan ports.HintScanResult |
| 27 | + | } |
| 28 | + | |
| 29 | + | func start(t *testing.T, timeout time.Duration) *harness { |
| 30 | + | return startWith(t, timeout, Options{}) |
| 31 | + | } |
| 32 | + | |
| 33 | + | func startWith(t *testing.T, timeout time.Duration, opts Options) *harness { |
| 34 | + | t.Helper() |
| 35 | + | h := &harness{ |
| 36 | + | requests: make(chan ports.HintScanRequest, 1), |
| 37 | + | captures: make(chan ports.CaptureRequest, 4), |
| 38 | + | captured: make(chan ports.CaptureDone, 1), |
| 39 | + | results: make(chan ports.HintScanResult, 4), |
| 40 | + | } |
| 41 | + | ctx, cancel := context.WithCancel(context.Background()) |
| 42 | + | exited := make(chan struct{}) |
| 43 | + | go func() { |
| 44 | + | defer close(exited) |
| 45 | + | _ = run(ctx, h.requests, h.captures, h.captured, h.results, timeout, opts) |
| 46 | + | }() |
| 47 | + | t.Cleanup(func() { cancel(); <-exited }) |
| 48 | + | return h |
| 49 | + | } |
| 50 | + | |
| 51 | + | func loadBGRA(t *testing.T) (pix []byte, w, hgt int) { |
| 52 | + | t.Helper() |
| 53 | + | f, err := os.Open("testdata/browser.png") |
| 54 | + | require.NoError(t, err) |
| 55 | + | defer f.Close() |
| 56 | + | img, _, err := image.Decode(f) |
| 57 | + | require.NoError(t, err) |
| 58 | + | b := img.Bounds() |
| 59 | + | rgba := image.NewRGBA(image.Rect(0, 0, b.Dx(), b.Dy())) |
| 60 | + | draw.Draw(rgba, rgba.Bounds(), img, b.Min, draw.Src) |
| 61 | + | for i := 0; i < len(rgba.Pix); i += 4 { |
| 62 | + | rgba.Pix[i], rgba.Pix[i+2] = rgba.Pix[i+2], rgba.Pix[i] |
| 63 | + | rgba.Pix[i+3] = 0xff |
| 64 | + | } |
| 65 | + | return rgba.Pix, b.Dx(), b.Dy() |
| 66 | + | } |
| 67 | + | |
| 68 | + | func TestHintScan(t *testing.T) { |
| 69 | + | pix, w, hgt := loadBGRA(t) |
| 70 | + | h := start(t, 5*time.Second) |
| 71 | + | |
| 72 | + | // Plays the output owner. |
| 73 | + | go func() { |
| 74 | + | creq := <-h.captures |
| 75 | + | copy(creq.Mapped, pix) |
| 76 | + | h.captured <- ports.CaptureDone{ID: creq.ID, Output: creq.Output} |
| 77 | + | }() |
| 78 | + | |
| 79 | + | h.requests <- ports.HintScanRequest{Seq: 7, Output: "HEADLESS-1", Width: w, Height: hgt, Scale: 1} |
| 80 | + | res := <-h.results |
| 81 | + | require.NoError(t, res.Err) |
| 82 | + | require.Equal(t, uint64(7), res.Seq) |
| 83 | + | require.Equal(t, "HEADLESS-1", res.Output) |
| 84 | + | var links int |
| 85 | + | for _, tg := range res.Targets { |
| 86 | + | require.Positive(t, tg.Rect.W) |
| 87 | + | require.Positive(t, tg.Rect.H) |
| 88 | + | if tg.Kind == ports.HintLink { |
| 89 | + | links++ |
| 90 | + | } |
| 91 | + | } |
| 92 | + | require.GreaterOrEqual(t, links, 1) |
| 93 | + | } |
| 94 | + | |
| 95 | + | func TestHintRequestShape(t *testing.T) { |
| 96 | + | h := start(t, 5*time.Second) |
| 97 | + | got := make(chan ports.CaptureRequest, 1) |
| 98 | + | go func() { |
| 99 | + | creq := <-h.captures |
| 100 | + | got <- creq |
| 101 | + | h.captured <- ports.CaptureDone{ID: creq.ID + 1} // another ID: ignored |
| 102 | + | h.captured <- ports.CaptureDone{ID: creq.ID, Output: creq.Output} // blank frame |
| 103 | + | }() |
| 104 | + | h.requests <- ports.HintScanRequest{Seq: 1, Output: "o", Width: 64, Height: 32, Scale: 1} |
| 105 | + | res := <-h.results |
| 106 | + | require.NoError(t, res.Err) |
| 107 | + | creq := <-got |
| 108 | + | require.NotZero(t, creq.ID&ports.CaptureIDInternal) |
| 109 | + | require.False(t, creq.Indicate) |
| 110 | + | require.Equal(t, image.Rect(0, 0, 64, 32), creq.Region) |
| 111 | + | require.Len(t, creq.Mapped, 64*32*4) |
| 112 | + | require.Equal(t, 64*4, creq.Stride) |
| 113 | + | require.Equal(t, uint32(1), creq.Format) |
| 114 | + | } |
| 115 | + | |
| 116 | + | func TestHintCaptureError(t *testing.T) { |
| 117 | + | h := start(t, 5*time.Second) |
| 118 | + | boom := errors.New("boom") |
| 119 | + | go func() { |
| 120 | + | creq := <-h.captures |
| 121 | + | h.captured <- ports.CaptureDone{ID: creq.ID, Err: boom} |
| 122 | + | }() |
| 123 | + | h.requests <- ports.HintScanRequest{Seq: 3, Output: "o", Width: 64, Height: 32, Scale: 1} |
| 124 | + | res := <-h.results |
| 125 | + | require.ErrorIs(t, res.Err, boom) |
| 126 | + | require.Equal(t, uint64(3), res.Seq) |
| 127 | + | require.Empty(t, res.Targets) |
| 128 | + | } |
| 129 | + | |
| 130 | + | func TestHintTimeout(t *testing.T) { |
| 131 | + | h := start(t, 50*time.Millisecond) |
| 132 | + | h.requests <- ports.HintScanRequest{Seq: 4, Output: "o", Width: 64, Height: 32, Scale: 1} |
| 133 | + | res := <-h.results |
| 134 | + | require.ErrorIs(t, res.Err, ErrTimeout) |
| 135 | + | require.Equal(t, uint64(4), res.Seq) |
| 136 | + | } |
| 137 | + | |
| 138 | + | func TestHintBusy(t *testing.T) { |
| 139 | + | h := start(t, 5*time.Second) |
| 140 | + | h.requests <- ports.HintScanRequest{Seq: 1, Output: "o", Width: 64, Height: 32, Scale: 1} |
| 141 | + | creq := <-h.captures |
| 142 | + | h.requests <- ports.HintScanRequest{Seq: 2, Output: "o", Width: 64, Height: 32, Scale: 1} |
| 143 | + | res := <-h.results |
| 144 | + | require.ErrorIs(t, res.Err, ErrBusy) |
| 145 | + | require.Equal(t, uint64(2), res.Seq) |
| 146 | + | h.captured <- ports.CaptureDone{ID: creq.ID} |
| 147 | + | res = <-h.results |
| 148 | + | require.NoError(t, res.Err) |
| 149 | + | require.Equal(t, uint64(1), res.Seq) |
| 150 | + | } |
| 151 | + | |
| 152 | + | func TestHintBadSize(t *testing.T) { |
| 153 | + | h := start(t, time.Second) |
| 154 | + | h.requests <- ports.HintScanRequest{Seq: 5, Output: "o"} |
| 155 | + | res := <-h.results |
| 156 | + | require.ErrorIs(t, res.Err, ErrBadRequest) |
| 157 | + | } |
| 158 | + | |
| 159 | + | func scanOnce(t *testing.T, h *harness, pix []byte, w, hgt int, seq uint64) ports.HintScanResult { |
| 160 | + | t.Helper() |
| 161 | + | go func() { |
| 162 | + | creq := <-h.captures |
| 163 | + | copy(creq.Mapped, pix) |
| 164 | + | h.captured <- ports.CaptureDone{ID: creq.ID, Output: creq.Output} |
| 165 | + | }() |
| 166 | + | h.requests <- ports.HintScanRequest{Seq: seq, Output: "HEADLESS-1", Width: w, Height: hgt, Scale: 1} |
| 167 | + | res := <-h.results |
| 168 | + | require.NoError(t, res.Err) |
| 169 | + | return res |
| 170 | + | } |
| 171 | + | |
| 172 | + | // waitFiles waits for the dump the worker writes after sending the result. |
| 173 | + | func waitFiles(t *testing.T, dir string, n int) []os.DirEntry { |
| 174 | + | t.Helper() |
| 175 | + | var entries []os.DirEntry |
| 176 | + | require.Eventually(t, func() bool { |
| 177 | + | entries, _ = os.ReadDir(dir) |
| 178 | + | return len(entries) >= n |
| 179 | + | }, 5*time.Second, 10*time.Millisecond) |
| 180 | + | return entries |
| 181 | + | } |
| 182 | + | |
| 183 | + | func TestHintDump(t *testing.T) { |
| 184 | + | pix, w, hgt := loadBGRA(t) |
| 185 | + | dir := filepath.Join(t.TempDir(), "hints") |
| 186 | + | h := startWith(t, 5*time.Second, Options{DumpDir: dir}) |
| 187 | + | res := scanOnce(t, h, pix, w, hgt, 1) |
| 188 | + | require.NotEmpty(t, res.Targets) |
| 189 | + | |
| 190 | + | entries := waitFiles(t, dir, 3) |
| 191 | + | // A second request is only served once the dump is written. |
| 192 | + | _ = scanOnceDone(t, h) |
| 193 | + | var png, ann, js string |
| 194 | + | for _, e := range entries { |
| 195 | + | info, err := e.Info() |
| 196 | + | require.NoError(t, err) |
| 197 | + | require.Equal(t, os.FileMode(0o600), info.Mode().Perm()) |
| 198 | + | switch { |
| 199 | + | case strings.HasSuffix(e.Name(), ".annotated.png"): |
| 200 | + | ann = e.Name() |
| 201 | + | case strings.HasSuffix(e.Name(), ".png"): |
| 202 | + | png = e.Name() |
| 203 | + | case strings.HasSuffix(e.Name(), ".json"): |
| 204 | + | js = e.Name() |
| 205 | + | } |
| 206 | + | } |
| 207 | + | require.NotEmpty(t, png) |
| 208 | + | require.NotEmpty(t, ann) |
| 209 | + | require.Regexp(t, `^\d{8}-\d{6}\.\d{3}-HEADLESS-1\.json$`, js) |
| 210 | + | |
| 211 | + | st, err := os.Stat(dir) |
| 212 | + | require.NoError(t, err) |
| 213 | + | require.Equal(t, os.FileMode(0o700), st.Mode().Perm()) |
| 214 | + | |
| 215 | + | data, err := os.ReadFile(filepath.Join(dir, js)) |
| 216 | + | require.NoError(t, err) |
| 217 | + | var meta struct { |
| 218 | + | Output string `json:"output"` |
| 219 | + | Width int `json:"width"` |
| 220 | + | Height int `json:"height"` |
| 221 | + | Stride int `json:"stride"` |
| 222 | + | Scale float64 `json:"scale"` |
| 223 | + | LinksOnly bool `json:"links_only"` |
| 224 | + | Targets []struct { |
| 225 | + | Kind string `json:"kind"` |
| 226 | + | Rect [4]int `json:"rect"` |
| 227 | + | } `json:"targets"` |
| 228 | + | } |
| 229 | + | require.NoError(t, json.Unmarshal(data, &meta)) |
| 230 | + | require.Equal(t, "HEADLESS-1", meta.Output) |
| 231 | + | require.Equal(t, w, meta.Width) |
| 232 | + | require.Equal(t, hgt, meta.Height) |
| 233 | + | require.Equal(t, w*4, meta.Stride) |
| 234 | + | require.Equal(t, 1.0, meta.Scale) |
| 235 | + | require.Len(t, meta.Targets, len(res.Targets)) |
| 236 | + | for i, tg := range res.Targets { |
| 237 | + | require.Equal(t, [4]int{tg.Rect.X, tg.Rect.Y, tg.Rect.X + tg.Rect.W, tg.Rect.Y + tg.Rect.H}, meta.Targets[i].Rect) |
| 238 | + | } |
| 239 | + | |
| 240 | + | f, err := os.Open(filepath.Join(dir, png)) |
| 241 | + | require.NoError(t, err) |
| 242 | + | defer f.Close() |
| 243 | + | img, _, err := image.Decode(f) |
| 244 | + | require.NoError(t, err) |
| 245 | + | require.Equal(t, image.Rect(0, 0, w, hgt), img.Bounds()) |
| 246 | + | r, g, b, _ := img.At(0, 0).RGBA() |
| 247 | + | require.Equal(t, uint32(pix[2])*0x101, r) |
| 248 | + | require.Equal(t, uint32(pix[1])*0x101, g) |
| 249 | + | require.Equal(t, uint32(pix[0])*0x101, b) |
| 250 | + | } |
| 251 | + | |
| 252 | + | // scanOnceDone sends a request that fails fast on a blank capture and waits |
| 253 | + | // for its result, which proves the previous dump finished. |
| 254 | + | func scanOnceDone(t *testing.T, h *harness) ports.HintScanResult { |
| 255 | + | t.Helper() |
| 256 | + | go func() { |
| 257 | + | creq := <-h.captures |
| 258 | + | h.captured <- ports.CaptureDone{ID: creq.ID, Err: errors.New("stop")} |
| 259 | + | }() |
| 260 | + | h.requests <- ports.HintScanRequest{Seq: 99, Output: "x", Width: 8, Height: 8, Scale: 1} |
| 261 | + | return <-h.results |
| 262 | + | } |
| 263 | + | |
| 264 | + | func TestHintDumpDisabled(t *testing.T) { |
| 265 | + | pix, w, hgt := loadBGRA(t) |
| 266 | + | dir := filepath.Join(t.TempDir(), "hints") |
| 267 | + | h := start(t, 5*time.Second) |
| 268 | + | scanOnce(t, h, pix, w, hgt, 1) |
| 269 | + | scanOnceDone(t, h) |
| 270 | + | _, err := os.Stat(dir) |
| 271 | + | require.ErrorIs(t, err, os.ErrNotExist) |
| 272 | + | } |
| 273 | + | |
| 274 | + | func TestHintDumpRetention(t *testing.T) { |
| 275 | + | dir := t.TempDir() |
| 276 | + | for i := 0; i < 60; i++ { |
| 277 | + | for _, ext := range []string{".png", ".annotated.png", ".json"} { |
| 278 | + | name := fmt.Sprintf("20260101-000000.%03d-o%s", i, ext) |
| 279 | + | require.NoError(t, os.WriteFile(filepath.Join(dir, name), nil, 0o600)) |
| 280 | + | } |
| 281 | + | } |
| 282 | + | require.NoError(t, prune(dir, maxDumps)) |
| 283 | + | entries, err := os.ReadDir(dir) |
| 284 | + | require.NoError(t, err) |
| 285 | + | require.Len(t, entries, maxDumps*3) |
| 286 | + | require.Equal(t, "20260101-000000.010-o.annotated.png", entries[0].Name()) |
| 287 | + | } |