package nativehost import ( "bytes" "clusterflow.dev/cfbrowser/internal/capture" "context" "encoding/json" "errors" "image" "image/png" "io" "os" "strings" "testing" "time" "clusterflow.dev/cfbrowser/api" "clusterflow.dev/cfbrowser/protocol" ) type fakeBackend struct { opts api.EngineOptions value json.RawMessage fail error pending func(error) async bool double bool asyncEvaluate bool finishEvaluate func(json.RawMessage, error) closedPages []uint64 closed bool } func (f *fakeBackend) Configure(o api.EngineOptions, done func(error)) { f.opts = o; done(f.fail) } func (f *fakeBackend) NewPage(_ uint64, done func(error)) { if f.async { f.pending = done return } done(f.fail) } func (f *fakeBackend) Navigate(_ uint64, url, op string, done func(string, error)) { done(url, f.fail) } func (f *fakeBackend) Evaluate(_ uint64, _ string, done func(json.RawMessage, error)) { if f.asyncEvaluate { f.finishEvaluate = done return } done(f.value, f.fail) if f.double { done(f.value, f.fail) } } func (f *fakeBackend) ClosePage(id uint64) error { f.closedPages = append(f.closedPages, id) return f.fail } func (f *fakeBackend) Close() { f.closed = true } // Dispatch one request on the test's UI thread, retaining native state ownership. func dispatch(t *testing.T, h *Host, method, raw string) (any, error) { t.Helper() done := make(chan result, 1) go func() { v, e := h.Handle(context.Background(), method, json.RawMessage(raw)); done <- result{v, e} }() select { case fn := <-h.Queue: fn() case r := <-done: return r.value, r.err case <-time.After(time.Second): t.Fatal("dispatch stalled") } select { case r := <-done: return r.value, r.err case <-time.After(time.Second): t.Fatal("completion stalled") } return nil, nil } func wantError(t *testing.T, e error, code string) { t.Helper() var typed *api.Error if !errors.As(e, &typed) || typed.Code != code { t.Fatalf("want %s, got %v", code, e) } } func TestHostValidationAndLifecycle(t *testing.T) { f := &fakeBackend{value: json.RawMessage(`{"answer":42}`)} h := New(f) _, e := dispatch(t, h, "page.new", "null") wantError(t, e, "BROWSER_INVALID_CONFIG") for _, raw := range []string{`{`, `{"ViewportWidth":-1}`, `{"ViewportHeight":4097}`} { _, e := dispatch(t, h, "configure", raw) if e == nil { t.Fatalf("accepted %s", raw) } } if v, e := dispatch(t, h, "configure", `{}`); e != nil || v != true { t.Fatal(v, e) } if f.opts.ViewportWidth != 1280 || f.opts.ViewportHeight != 800 { t.Fatal(f.opts) } _, e = dispatch(t, h, "configure", `{}`) wantError(t, e, "BROWSER_INVALID_CONFIG") _, e = dispatch(t, h, "page.close", `{`) wantError(t, e, "BROWSER_INVALID_ARGUMENT") _, e = dispatch(t, h, "unknown", `{}`) wantError(t, e, "BROWSER_CAPABILITY_UNSUPPORTED") _, e = dispatch(t, h, "page.evaluate", `{"page":999}`) wantError(t, e, "BROWSER_PAGE_NOT_FOUND") for i := uint64(1); i <= 16; i++ { v, e := dispatch(t, h, "page.new", `null`) if e != nil || v != i { t.Fatal(v, e) } } _, e = dispatch(t, h, "page.new", `null`) wantError(t, e, "BROWSER_LIMIT") _, e = dispatch(t, h, "page.navigate", `{"page":1,"op":"invalid"}`) wantError(t, e, "BROWSER_INVALID_ARGUMENT") _, e = dispatch(t, h, "page.navigate", `{"page":1,"op":"goto","url":"x\u0000y"}`) wantError(t, e, "BROWSER_INVALID_ARGUMENT") _, e = dispatch(t, h, "page.evaluate", `{"page":1,"script":"x\u0000y"}`) wantError(t, e, "BROWSER_INVALID_ARGUMENT") for _, op := range []string{"goto", "back", "forward", "reload"} { v, e := dispatch(t, h, "page.navigate", `{"page":1,"op":"`+op+`","url":"https://example.org"}`) if e != nil || v != "https://example.org" { t.Fatal(v, e) } } v, e := dispatch(t, h, "page.evaluate", `{"page":1,"script":"42"}`) if e != nil || string(v.(json.RawMessage)) != string(f.value) { t.Fatal(v, e) } f.value = json.RawMessage(`invalid`) _, e = dispatch(t, h, "page.evaluate", `{"page":1}`) wantError(t, e, "BROWSER_INVALID_RESULT") f.value = json.RawMessage(`"` + strings.Repeat("x", protocol.MaxMessage) + `"`) _, e = dispatch(t, h, "page.evaluate", `{"page":1}`) wantError(t, e, "BROWSER_INVALID_RESULT") args, _ := json.Marshal(map[string]any{"page": 1, "script": strings.Repeat("x", protocol.MaxMessage)}) _, e = dispatch(t, h, "page.evaluate", string(args)) wantError(t, e, "BROWSER_ARGUMENT_LIMIT") f.fail = errors.New("engine failed") _, e = dispatch(t, h, "page.evaluate", `{"page":1}`) if !errors.Is(e, f.fail) { t.Fatal(e) } f.fail = nil _, e = dispatch(t, h, "page.close", `{"page":1}`) if e != nil || len(f.closedPages) != 1 { t.Fatal(e, f.closedPages) } h.Close() if !f.closed || len(h.pages) != 0 { t.Fatal("not closed") } } func TestHostCreationFailuresAndCancellation(t *testing.T) { f := &fakeBackend{fail: errors.New("startup failed")} h := New(f) _, e := dispatch(t, h, "configure", `{}`) if e == nil || h.configured { t.Fatal(e) } f.fail = nil _, _ = dispatch(t, h, "configure", `{}`) f.fail = errors.New("new page failed") _, e = dispatch(t, h, "page.new", `null`) if e == nil || len(h.pages) != 0 { t.Fatal(e) } f.fail = nil f.async = true ctx, cancel := context.WithCancel(context.Background()) done := make(chan error, 1) go func() { _, e := h.Handle(ctx, "page.new", nil); done <- e }() (<-h.Queue)() cancel() if e := <-done; !errors.Is(e, context.Canceled) { t.Fatal(e) } f.pending(nil) if len(h.pages) != 0 || len(f.closedPages) != 1 { t.Fatal("canceled creation leaked", h.pages, f.closedPages) } ctx, cancel = context.WithCancel(context.Background()) cancel() if _, e := h.Handle(ctx, "page.new", nil); !errors.Is(e, context.Canceled) { t.Fatal(e) } // Cancellation after enqueue must prevent a native side effect. ctx, cancel = context.WithCancel(context.Background()) go func() { _, e := h.Handle(ctx, "page.new", nil); done <- e }() fn := <-h.Queue cancel() fn() <-done if len(h.pages) != 0 { t.Fatal("dispatched after cancellation") } } func TestRunFramedRPCAndShutdown(t *testing.T) { input, writer := io.Pipe() reader, output := io.Pipe() f := &fakeBackend{value: json.RawMessage(`true`)} done := make(chan error, 1) go func() { done <- Run(context.Background(), input, output, f, func() error { return nil }) output.Close() }() client := protocol.NewClient(reader, writer) defer client.Close() ctx, cancel := context.WithTimeout(context.Background(), time.Second) defer cancel() var ok bool if e := client.Call(ctx, "configure", api.EngineOptions{}, &ok); e != nil || !ok { t.Fatal(ok, e) } var id uint64 if e := client.Call(ctx, "page.new", nil, &id); e != nil || id != 1 { t.Fatal(id, e) } writer.Close() select { case e := <-done: if e != nil { t.Fatal(e) } case <-ctx.Done(): t.Fatal("EOF shutdown stalled") } if !f.closed { t.Fatal("backend not closed") } } func TestRunPumpFailure(t *testing.T) { input, writer := io.Pipe() defer writer.Close() f := &fakeBackend{} failure := errors.New("pump failed") if e := Run(context.Background(), input, io.Discard, f, func() error { return failure }); !errors.Is(e, failure) { t.Fatal(e) } if !f.closed { t.Fatal("backend leaked") } } func TestNativeEvaluationQuotaAndQueueCancellation(t *testing.T) { f := &fakeBackend{value: json.RawMessage(`null`)} h := New(f) _, _ = dispatch(t, h, "configure", `{}`) _, _ = dispatch(t, h, "page.new", `null`) // A timed-out native call can still be executing; the native quota survives RPC cancellation. h.evaluations = 32 _, e := dispatch(t, h, "page.evaluate", `{"page":1}`) wantError(t, e, "BROWSER_LIMIT") h.evaluations = 31 f.double = true if _, e = dispatch(t, h, "page.evaluate", `{"page":1}`); e != nil || h.evaluations != 31 { t.Fatal(e, h.evaluations) } for i := 0; i < cap(h.Queue); i++ { h.Queue <- func() {} } ctx, cancel := context.WithTimeout(context.Background(), 5*time.Millisecond) defer cancel() if _, e = h.Handle(ctx, "page.new", nil); !errors.Is(e, context.DeadlineExceeded) { t.Fatal(e) } } func TestCloseReleasesPendingEvaluationAndIgnoresLateResult(t *testing.T) { for _, closeHost := range []bool{false, true} { t.Run(map[bool]string{false: "page", true: "host"}[closeHost], func(t *testing.T) { f := &fakeBackend{asyncEvaluate: true} h := New(f) _, _ = dispatch(t, h, "configure", `{}`) _, _ = dispatch(t, h, "page.new", `null`) done := make(chan error, 1) go func() { _, e := h.Handle(context.Background(), "page.evaluate", json.RawMessage(`{"page":1}`)) done <- e }() (<-h.Queue)() if h.evaluations != 1 { t.Fatal(h.evaluations) } if closeHost { h.Close() } else { _, _ = dispatch(t, h, "page.close", `{"page":1}`) } wantError(t, <-done, "BROWSER_CLOSED") f.finishEvaluate(json.RawMessage(`true`), nil) if h.evaluations != 0 || len(h.pending) != 0 { t.Fatal("pending evaluation leaked", h.evaluations, h.pending) } }) } } type featureBackend struct { fakeBackend image []byte captureDone func([]byte, error) inputCount int } func (f *featureBackend) Capture(_ uint64, _ bool, done func([]byte, error)) { if f.image == nil { f.captureDone = done } else { done(f.image, nil) } } func (f *featureBackend) Input(_ uint64, _ string, _ string, _ float64, _ float64, done func(error)) { f.inputCount++ done(nil) } func TestCaptureInputAndFeatureHandshake(t *testing.T) { var pngData bytes.Buffer _ = png.Encode(&pngData, image.NewRGBA(image.Rect(0, 0, 16, 16))) f := &featureBackend{image: pngData.Bytes()} h := New(f) dir := t.TempDir() opts, _ := json.Marshal(api.EngineOptions{DownloadDir: dir}) if _, err := dispatch(t, h, "configure", string(opts)); err != nil { t.Fatal(err) } v, err := dispatch(t, h, "session.features", `null`) if err != nil || v.(map[string]int)["featureVersion"] != protocol.FeatureVersion { t.Fatal(v, err) } _, _ = dispatch(t, h, "page.new", `null`) token, err := dispatch(t, h, "page.capture", `{"page":1}`) if err != nil { t.Fatal(err) } data, err := capture.Load(dir, token.(string)) if err != nil || !bytes.Equal(data, pngData.Bytes()) { t.Fatal(err) } if _, err = dispatch(t, h, "page.input", `{"page":1,"action":"click"}`); err != nil || f.inputCount != 1 { t.Fatal(err) } if h.evaluations != 0 { t.Fatal("pending quota leaked") } f.image = nil waiting := make(chan error, 1) go func() { _, err := h.Handle(context.Background(), "page.capture", json.RawMessage(`{"page":1}`)) waiting <- err }() (<-h.Queue)() _, _ = dispatch(t, h, "page.close", `{"page":1}`) wantError(t, <-waiting, "BROWSER_CLOSED") f.captureDone(pngData.Bytes(), nil) files, _ := os.ReadDir(dir) if len(files) != 0 || h.evaluations != 0 { t.Fatal("late capture persisted", files) } }