Skip to content

Commit 2e87c74

Browse files
authored
fix: Use UI identity for background change detection in Effect (#23980)
EffectContext.isBackgroundChange() always returned false for shared signals modified by another user's session because the check only looked at VaadinRequest.getCurrent(), which is non-null on any request thread. Now Effect tracks its owner UI and compares UI.getCurrent() against it, correctly detecting cross-session changes as background changes. Fixes #23979
1 parent 04759ce commit 2e87c74

4 files changed

Lines changed: 159 additions & 7 deletions

File tree

‎flow-server/src/main/java/com/vaadin/flow/dom/ElementEffect.java‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -317,6 +317,7 @@ private void enableEffect(Element owner) {
317317
effect.setDispatcher(uiDispatcher);
318318
effect.activate();
319319
}
320+
effect.setOwnerUI(ui);
320321
}
321322

322323
private void disableEffect() {

‎flow-server/src/main/java/com/vaadin/flow/signals/impl/Effect.java‎

Lines changed: 23 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -23,6 +23,7 @@
2323

2424
import org.jspecify.annotations.Nullable;
2525

26+
import com.vaadin.flow.component.UI;
2627
import com.vaadin.flow.function.SerializableExecutor;
2728
import com.vaadin.flow.function.SerializableRunnable;
2829
import com.vaadin.flow.internal.UsageStatistics;
@@ -60,6 +61,8 @@ public class Effect implements Serializable {
6061

6162
private final AtomicBoolean invalidateScheduled = new AtomicBoolean(false);
6263

64+
private @Nullable UI ownerUI;
65+
6366
private boolean firstRun = true;
6467
private volatile boolean invalidatedFromBackground = false;
6568
private boolean passivated = false;
@@ -212,7 +215,11 @@ private boolean onDependencyChange(boolean immediate) {
212215
"Infinite loop detected between effect updates. This effect is deactivated.");
213216
}
214217

215-
invalidatedFromBackground = VaadinRequest.getCurrent() == null;
218+
if (ownerUI != null) {
219+
invalidatedFromBackground = UI.getCurrent() != ownerUI;
220+
} else {
221+
invalidatedFromBackground = VaadinRequest.getCurrent() == null;
222+
}
216223
scheduleInvalidate();
217224
return false;
218225
}
@@ -247,6 +254,21 @@ private void clearRegistrations() {
247254
registrations.clear();
248255
}
249256

257+
/**
258+
* Sets the owner UI for this effect. When set, background change detection
259+
* compares {@link UI#getCurrent()} against this UI instead of only checking
260+
* for the presence of a {@link VaadinRequest}. This allows effects to
261+
* correctly detect changes triggered by another user's session on a shared
262+
* signal.
263+
*
264+
* @param ui
265+
* the owner UI, or {@code null} to fall back to
266+
* VaadinRequest-based detection
267+
*/
268+
public void setOwnerUI(@Nullable UI ui) {
269+
this.ownerUI = ui;
270+
}
271+
250272
/**
251273
* Sets the dispatcher to use for subsequent invalidation callbacks. This
252274
* can be used to change the execution context before re-activating a

‎flow-server/src/test/java/com/vaadin/flow/dom/ElementEffectTest.java‎

Lines changed: 8 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -193,21 +193,23 @@ void contextAwareEffect_detectsBackgroundChange() {
193193
assertFalse(backgroundChanges.get(0),
194194
"Initial run should not be a background change");
195195

196-
// Change signal with VaadinRequest present (simulates user request)
196+
// Change signal with same UI current (simulates user request)
197197
signal.set("from request");
198198

199199
assertEquals(2, backgroundChanges.size());
200200
assertFalse(backgroundChanges.get(1),
201-
"Change with VaadinRequest should not be a background change");
201+
"Change with same UI should not be a background change");
202202

203-
// Clear VaadinRequest to simulate background change
203+
// Clearing only VaadinRequest while the same UI is still current
204+
// is NOT a background change: the effect's owner UI matches
204205
CurrentInstance.set(VaadinRequest.class, null);
205206

206-
signal.set("from background");
207+
signal.set("from same ui without request");
207208

208209
assertEquals(3, backgroundChanges.size());
209-
assertTrue(backgroundChanges.get(2),
210-
"Change without VaadinRequest should be a background change");
210+
assertFalse(backgroundChanges.get(2),
211+
"Change from same UI should not be a background change "
212+
+ "even without VaadinRequest");
211213
}
212214

213215
@Test

‎flow-server/src/test/java/com/vaadin/flow/signals/impl/EffectTest.java‎

Lines changed: 127 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -22,20 +22,27 @@
2222
import java.util.concurrent.atomic.AtomicInteger;
2323

2424
import org.junit.jupiter.api.Test;
25+
import org.mockito.Mockito;
2526

27+
import com.vaadin.flow.component.UI;
28+
import com.vaadin.flow.internal.CurrentInstance;
29+
import com.vaadin.flow.server.VaadinRequest;
2630
import com.vaadin.flow.shared.Registration;
2731
import com.vaadin.flow.signals.MissingSignalUsageException;
2832
import com.vaadin.flow.signals.Signal;
2933
import com.vaadin.flow.signals.SignalTestBase;
3034
import com.vaadin.flow.signals.TestUtil;
3135
import com.vaadin.flow.signals.impl.UsageTracker.Usage;
36+
import com.vaadin.flow.signals.local.ValueSignal;
3237
import com.vaadin.flow.signals.shared.SharedListSignal;
3338
import com.vaadin.flow.signals.shared.SharedMapSignal;
3439
import com.vaadin.flow.signals.shared.SharedValueSignal;
3540
import com.vaadin.flow.signals.shared.SharedValueSignalTest.AsyncSharedValueSignal;
3641

3742
import static org.junit.jupiter.api.Assertions.assertEquals;
43+
import static org.junit.jupiter.api.Assertions.assertFalse;
3844
import static org.junit.jupiter.api.Assertions.assertThrows;
45+
import static org.junit.jupiter.api.Assertions.assertTrue;
3946

4047
class EffectTest extends SignalTestBase {
4148

@@ -774,4 +781,124 @@ public Registration onNextChange(
774781
dispatcher.runPendingTasks();
775782
assertEquals(List.of("signal", "update"), invocations);
776783
}
784+
785+
@Test
786+
void ownerUI_sameUICurrent_notBackgroundChange() {
787+
UI ui = Mockito.mock(UI.class);
788+
UI.setCurrent(ui);
789+
790+
ValueSignal<String> signal = new ValueSignal<>("hello");
791+
List<Boolean> backgroundChanges = new ArrayList<>();
792+
793+
Effect effect = new Effect(ctx -> {
794+
signal.get();
795+
backgroundChanges.add(ctx.isBackgroundChange());
796+
}, Runnable::run);
797+
effect.setOwnerUI(ui);
798+
799+
assertEquals(1, backgroundChanges.size());
800+
assertFalse(backgroundChanges.get(0));
801+
802+
signal.set("update");
803+
804+
assertEquals(2, backgroundChanges.size());
805+
assertFalse(backgroundChanges.get(1),
806+
"Change with same UI should not be background");
807+
}
808+
809+
@Test
810+
void ownerUI_noUICurrent_isBackgroundChange() {
811+
UI ui = Mockito.mock(UI.class);
812+
UI.setCurrent(ui);
813+
814+
ValueSignal<String> signal = new ValueSignal<>("hello");
815+
List<Boolean> backgroundChanges = new ArrayList<>();
816+
817+
Effect effect = new Effect(ctx -> {
818+
signal.get();
819+
backgroundChanges.add(ctx.isBackgroundChange());
820+
}, Runnable::run);
821+
effect.setOwnerUI(ui);
822+
823+
assertEquals(1, backgroundChanges.size());
824+
825+
UI.setCurrent(null);
826+
signal.set("from background");
827+
828+
assertEquals(2, backgroundChanges.size());
829+
assertTrue(backgroundChanges.get(1),
830+
"Change without UI should be background");
831+
}
832+
833+
@Test
834+
void ownerUI_differentUICurrent_isBackgroundChange() {
835+
UI uiA = Mockito.mock(UI.class);
836+
UI uiB = Mockito.mock(UI.class);
837+
838+
ValueSignal<String> signal = new ValueSignal<>("initial");
839+
List<Boolean> backgroundChangesA = new ArrayList<>();
840+
List<Boolean> backgroundChangesB = new ArrayList<>();
841+
842+
UI.setCurrent(uiA);
843+
Effect effectA = new Effect(ctx -> {
844+
signal.get();
845+
backgroundChangesA.add(ctx.isBackgroundChange());
846+
}, Runnable::run);
847+
effectA.setOwnerUI(uiA);
848+
849+
UI.setCurrent(uiB);
850+
Effect effectB = new Effect(ctx -> {
851+
signal.get();
852+
backgroundChangesB.add(ctx.isBackgroundChange());
853+
}, Runnable::run);
854+
effectB.setOwnerUI(uiB);
855+
856+
assertEquals(1, backgroundChangesA.size());
857+
assertEquals(1, backgroundChangesB.size());
858+
859+
// User A modifies the signal
860+
UI.setCurrent(uiA);
861+
signal.set("from user A");
862+
863+
assertEquals(2, backgroundChangesA.size());
864+
assertFalse(backgroundChangesA.get(1),
865+
"Change from own UI should not be background");
866+
867+
assertEquals(2, backgroundChangesB.size());
868+
assertTrue(backgroundChangesB.get(1),
869+
"Change from another UI should be background");
870+
}
871+
872+
@Test
873+
void noOwnerUI_fallsBackToVaadinRequestCheck() {
874+
VaadinRequest mockRequest = Mockito.mock(VaadinRequest.class);
875+
CurrentInstance.set(VaadinRequest.class, mockRequest);
876+
877+
ValueSignal<String> signal = new ValueSignal<>("hello");
878+
List<Boolean> backgroundChanges = new ArrayList<>();
879+
880+
// Effect without ownerUI (like Signal.unboundEffect)
881+
new Effect(ctx -> {
882+
signal.get();
883+
backgroundChanges.add(ctx.isBackgroundChange());
884+
}, Runnable::run);
885+
886+
assertEquals(1, backgroundChanges.size());
887+
assertFalse(backgroundChanges.get(0));
888+
889+
// Change with VaadinRequest present — not background
890+
signal.set("with request");
891+
892+
assertEquals(2, backgroundChanges.size());
893+
assertFalse(backgroundChanges.get(1),
894+
"Change with VaadinRequest should not be background");
895+
896+
// Clear VaadinRequest — background
897+
CurrentInstance.set(VaadinRequest.class, null);
898+
signal.set("without request");
899+
900+
assertEquals(3, backgroundChanges.size());
901+
assertTrue(backgroundChanges.get(2),
902+
"Change without VaadinRequest should be background");
903+
}
777904
}

0 commit comments

Comments
 (0)