Skip to content

High-performance browser automation bridge and multi-instance orchestrator with advanced stealth injection and real-time dashboard.

refactor: extract orderSolvers out of trySolvers and test it directly (PIN-054)

Luigi Agosti14639eff294d
diff --git a/internal/autosolver/autosolver.go b/internal/autosolver/autosolver.go
index 0d72bdd8..cffe1746 100644
--- a/internal/autosolver/autosolver.go
+++ b/internal/autosolver/autosolver.go
@@ -174,6 +174,46 @@ func (as *AutoSolver) detectIntent(ctx context.Context, page Page) (*Intent, err
return detectIntentByTitle(page.Title()), nil
}
+func (as *AutoSolver) orderSolvers(matching []Solver) []Solver {
+ if len(as.config.Solvers) == 0 {
+ return matching
+ }
+
+ byName := make(map[string]Solver, len(matching))
+ for _, s := range matching {
+ byName[s.Name()] = s
+ }
+
+ filtered := make([]Solver, 0, len(as.config.Solvers))
+ missing := make([]string, 0, len(as.config.Solvers))
+ for _, name := range as.config.Solvers {
+ if s, ok := byName[name]; ok {
+ filtered = append(filtered, s)
+ continue
+ }
+ missing = append(missing, name)
+ }
+
+ if len(filtered) == 0 {
+ available := make([]string, 0, len(byName))
+ for name := range byName {
+ available = append(available, name)
+ }
+ sort.Strings(available)
+ slog.Debug("autosolver: configured solver order not found, using priority order",
+ "configured", as.config.Solvers,
+ "available", available)
+ return matching
+ }
+
+ if len(missing) > 0 {
+ slog.Debug("autosolver: some configured solvers unavailable; using matched subset",
+ "configured", as.config.Solvers,
+ "missing", missing)
+ }
+ return filtered
+}
+
func (as *AutoSolver) trySolvers(ctx context.Context, page Page, executor ActionExecutor) (bool, []AttemptEntry) {
solvers := as.registry.MatchingSolvers(ctx, page)
if len(solvers) == 0 {
@@ -183,41 +223,7 @@ func (as *AutoSolver) trySolvers(ctx context.Context, page Page, executor Action
}}
}
- orderedSolvers := solvers
- if len(as.config.Solvers) > 0 {
- byName := make(map[string]Solver, len(solvers))
- for _, s := range solvers {
- byName[s.Name()] = s
- }
-
- filtered := make([]Solver, 0, len(as.config.Solvers))
- missing := make([]string, 0, len(as.config.Solvers))
- for _, name := range as.config.Solvers {
- if s, ok := byName[name]; ok {
- filtered = append(filtered, s)
- continue
- }
- missing = append(missing, name)
- }
-
- if len(filtered) > 0 {
- if len(missing) > 0 {
- slog.Debug("autosolver: some configured solvers unavailable; using matched subset",
- "configured", as.config.Solvers,
- "missing", missing)
- }
- orderedSolvers = filtered
- } else {
- available := make([]string, 0, len(byName))
- for name := range byName {
- available = append(available, name)
- }
- sort.Strings(available)
- slog.Debug("autosolver: configured solver order not found, using priority order",
- "configured", as.config.Solvers,
- "available", available)
- }
- }
+ orderedSolvers := as.orderSolvers(solvers)
entries := make([]AttemptEntry, 0, len(orderedSolvers))
for _, s := range orderedSolvers {
diff --git a/internal/autosolver/autosolver_test.go b/internal/autosolver/autosolver_test.go
index 3bb620dc..3c5800da 100644
--- a/internal/autosolver/autosolver_test.go
+++ b/internal/autosolver/autosolver_test.go
@@ -3,6 +3,7 @@ package autosolver
import (
"context"
"fmt"
+ "reflect"
"strings"
"testing"
"time"
@@ -999,3 +1000,76 @@ func TestExecuteAction_LLMNavigate(t *testing.T) {
t.Errorf("expected navigate, got %d", ex.navigateCalled)
}
}
+
+func solverNames(solvers []Solver) []string {
+ names := make([]string, 0, len(solvers))
+ for _, s := range solvers {
+ names = append(names, s.Name())
+ }
+ return names
+}
+
+func TestOrderSolvers(t *testing.T) {
+ priorityOrder := []Solver{
+ &mockSolver{name: "alpha", priority: 10},
+ &mockSolver{name: "beta", priority: 20},
+ &mockSolver{name: "gamma", priority: 30},
+ }
+
+ for _, tc := range []struct {
+ name string
+ configured []string
+ want []string
+ }{
+ {
+ name: "all configured names present, configured order wins",
+ configured: []string{"gamma", "alpha", "beta"},
+ want: []string{"gamma", "alpha", "beta"},
+ },
+ {
+ name: "some configured names missing, matched subset in configured order",
+ configured: []string{"gamma", "absent", "alpha"},
+ want: []string{"gamma", "alpha"},
+ },
+ {
+ name: "no configured name matches, priority order unchanged",
+ configured: []string{"absent", "also-absent"},
+ want: []string{"alpha", "beta", "gamma"},
+ },
+ {
+ name: "empty config, priority order unchanged",
+ configured: nil,
+ want: []string{"alpha", "beta", "gamma"},
+ },
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ as := New(Config{Solvers: tc.configured}, nil, nil)
+
+ got := solverNames(as.orderSolvers(priorityOrder))
+
+ if !reflect.DeepEqual(got, tc.want) {
+ t.Fatalf("orderSolvers = %v, want %v", got, tc.want)
+ }
+ for _, name := range got {
+ if name == "absent" || name == "also-absent" {
+ t.Errorf("unconfigured-but-missing name %q leaked into the result %v", name, got)
+ }
+ }
+ })
+ }
+}
+
+func TestOrderSolversDoesNotMutateInput(t *testing.T) {
+ priorityOrder := []Solver{
+ &mockSolver{name: "alpha", priority: 10},
+ &mockSolver{name: "beta", priority: 20},
+ }
+ before := solverNames(priorityOrder)
+
+ as := New(Config{Solvers: []string{"beta", "alpha"}}, nil, nil)
+ _ = as.orderSolvers(priorityOrder)
+
+ if after := solverNames(priorityOrder); !reflect.DeepEqual(before, after) {
+ t.Fatalf("input reordered in place: %v -> %v", before, after)
+ }
+}