backend/unbounded: test PatchSettings dispatches UnboundedKey

A typo on the diff key (settings.UnboundedKey →
settings.UnboundedKye) or a removal of the unbounded.Apply()
call would silently leave the UI toggle persisted but inert.
The peer-share side has TestPatchSettings_PeerShareDispatches
catching exactly this class of regression; mirror it for
Unbounded.

unbounded/unbounded.go:
- Add applyHook: a nil-in-production function pointer invoked
  at the top of Apply(), before any state check. Backend tests
  install a counter via SetApplyHookForTest to verify dispatch.
  This is the smallest possible test surface — exposing the
  manager's internals across packages just for the test wiring
  would be a much bigger surface, and the hook fires regardless
  of the Enabled() gate so tests catch dispatch even when no
  transition results.

backend/radiance_test.go:
- TestPatchSettings_UnboundedDispatches: install the hook,
  PATCH {UnboundedKey:true}, assert hook fired once; PATCH
  {UnboundedKey:false}, assert hook fired twice. Then PATCH
  {PeerShareEnabledKey:false} (a key OTHER than UnboundedKey)
  and assert the counter doesn't move — confirms the diff
  check is in place rather than always firing.

Sanity-checked the test by removing the Apply call from
PatchSettings: test fails with 'expected 2, actual 0'.
Restored: test passes.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: myleshorton

backend/radiance_test.go

@@ -13,6 +13,7 @@ import (
 
 	"github.com/getlantern/radiance/common/settings"
 	"github.com/getlantern/radiance/peer"
+	"github.com/getlantern/radiance/unbounded"
 )
 
 func TestBackend(t *testing.T) {}
@@ -216,3 +217,28 @@ func TestPatchSettings_PeerShareDispatches(t *testing.T) {
 	assert.Equal(t, int64(1), fake.stopCalls.Load())
 	assert.False(t, fake.IsActive())
 }
+
+// Verify PatchSettings routes UnboundedKey to unbounded.Apply via the
+// SetApplyHookForTest hook. Companion to TestPatchSettings_PeerShareDispatches —
+// a typo on the diff key or a removal of the Apply call would silently
+// leave the Unbounded toggle persisted but inert. The hook fires
+// regardless of the Enabled() gate inside Apply, so this catches the
+// dispatch even though we don't prime the rest of the manager state.
+func TestPatchSettings_UnboundedDispatches(t *testing.T) {
+	r := newPeerTestBackend(t, &fakePeerController{})
+
+	var applyCalls atomic.Int32
+	unbounded.SetApplyHookForTest(func() { applyCalls.Add(1) })
+	t.Cleanup(func() { unbounded.SetApplyHookForTest(nil) })
+
+	require.NoError(t, r.PatchSettings(settings.Settings{settings.UnboundedKey: true}))
+	assert.Equal(t, int32(1), applyCalls.Load(), "PatchSettings({UnboundedKey: true}) must dispatch to unbounded.Apply")
+
+	require.NoError(t, r.PatchSettings(settings.Settings{settings.UnboundedKey: false}))
+	assert.Equal(t, int32(2), applyCalls.Load(), "PatchSettings({UnboundedKey: false}) must dispatch to unbounded.Apply")
+
+	// A PATCH without UnboundedKey must NOT trigger Apply — confirms
+	// the diff check is in place rather than always firing.
+	require.NoError(t, r.PatchSettings(settings.Settings{settings.PeerShareEnabledKey: false}))
+	assert.Equal(t, int32(2), applyCalls.Load(), "PatchSettings without UnboundedKey must not dispatch to unbounded.Apply")
+}

unbounded/unbounded.go

@@ -200,6 +200,9 @@ func SetEnabled(enable bool) error {
 // armed gate is also checked inside start, so even a queued
 // transition stays a no-op after Stop.
 func Apply() error {
+	if h := applyHook; h != nil {
+		h()
+	}
 	if !Enabled() {
 		manager.stop()
 		return nil
@@ -337,6 +340,23 @@ func Stop(ctx context.Context) error {
 // applies for the duration of the test.
 var internalStopTimeout = 5 * time.Second
 
+// applyHook is invoked at the top of Apply, before any state check
+// or transition. nil in production; backend tests install a counter
+// or assertion to verify that PatchSettings actually dispatches the
+// UnboundedKey diff to this package. Keep this minimal — exposing
+// the manager's internals across packages just for test wiring
+// would be a much bigger surface.
+var applyHook func()
+
+// SetApplyHookForTest installs h to be invoked at the start of
+// every Apply call. Pass nil to remove. Test-only; production code
+// must not call this. The hook fires regardless of the Enabled()
+// gate so callers can verify dispatch happened even when no
+// transition results.
+func SetApplyHookForTest(h func()) {
+	applyHook = h
+}
+
 // stopCtx is the shared implementation for both the public Stop
 // (disarm=true) and internal manager.stop (disarm=false). Holds
 // transitionMu for the entire signal+wait so a concurrent start