feat: Make signal environment init optional (#22074)

* Make signal environment init optional

Also removes the duplicate ___staticMocks variants in
VaadinServiceSignalsInitializationTest

Fixes #22033

* Update omitted Javadoc reference

* Preserve original import order

---------

Co-authored-by: Mikhail Shabarov <61410877+mshabarov@users.noreply.github.com>

Author: Legioth

flow-server/src/main/java/com/vaadin/flow/server/VaadinService.java

@@ -51,7 +51,6 @@
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;
-import java.util.function.Supplier;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
@@ -357,51 +356,66 @@ public void init() throws ServiceException {
     }
 
     private void initSignalsEnvironment() {
-        Executor signalsExecutor;
-        Supplier<Executor> flowDispatcherOverride;
-        FeatureFlags featureFlags = FeatureFlags.get(getContext());
-        if (featureFlags
-                .isEnabled(FeatureFlags.FLOW_FULLSTACK_SIGNALS.getId())) {
-            // Use getter method to trigger a multiple TaskExecutor check
-            signalsExecutor = getExecutor();
-            flowDispatcherOverride = () -> {
+        boolean enabled = FeatureFlags.get(getContext())
+                .isEnabled(FeatureFlags.FLOW_FULLSTACK_SIGNALS.getId());
+        if (enabled) {
+            // Trigger check for multiple TaskExecutor candidates
+            getExecutor();
+        }
+
+        class VaadinServiceEnvironment extends SignalEnvironment
+                implements Serializable {
+            @Override
+            public boolean isActive() {
+                if (VaadinService.getCurrent() != VaadinService.this) {
+                    return false;
+                } else if (!enabled) {
+                    throw new DisabledFeatureException(
+                            FeatureFlags.FLOW_FULLSTACK_SIGNALS);
+                } else {
+                    return true;
+                }
+            }
+
+            private Executor createCurrentUiDispatcher() {
                 UI owner = UI.getCurrent();
                 if (owner == null) {
-                    return null;
+                    return getExecutor();
                 }
 
                 return task -> {
                     if (UI.getCurrent() == owner) {
                         task.run();
                     } else {
                         try {
-                            SignalEnvironment.defaultDispatcher()
+                            getExecutor()
                                     .execute(() -> owner.access(task::run));
                         } catch (Exception e) {
-                            // a task is submitted when executor is shut down,
-                            // ignore
+                            // submitted when executor is shut down, ignore
                         }
                     }
                 };
-            };
-        } else {
-            signalsExecutor = task -> {
-                throw new DisabledFeatureException(
-                        FeatureFlags.FLOW_FULLSTACK_SIGNALS);
-            };
-            flowDispatcherOverride = () -> {
-                throw new DisabledFeatureException(
-                        FeatureFlags.FLOW_FULLSTACK_SIGNALS);
-            };
-        }
-        if (!SignalEnvironment.tryInitialize(createDefaultObjectMapper(),
-                signalsExecutor)) {
-            getLogger().warn("Signals environment is already initialized. "
-                    + "It is recommended to let Vaadin setup Signals environment to prevent unexpected behavior. "
-                    + "Please, avoid calling SignalEnvironment.tryInitialize() in application code.");
+            }
+
+            @Override
+            public Executor getResultNotifier() {
+                return createCurrentUiDispatcher();
+            }
+
+            @Override
+            public Executor getEffectDispatcher() {
+                return createCurrentUiDispatcher();
+            }
+
+            @Override
+            public Executor getFallbackEffectDispatcher() {
+                return getExecutor();
+            }
         }
+
         Runnable unregister = SignalEnvironment
-                .addDispatcherOverride(flowDispatcherOverride);
+                .register(new VaadinServiceEnvironment());
+
         addServiceDestroyListener(event -> unregister.run());
     }
 

flow-server/src/test/java/com/vaadin/flow/component/ComponentEffectTest.java

@@ -16,51 +16,29 @@
 package com.vaadin.flow.component;
 
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertThrows;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.mockStatic;
 import static org.mockito.Mockito.when;
 
-import java.util.ArrayList;
-import java.util.List;
 import java.util.Locale;
-import java.util.concurrent.Executor;
-import java.util.concurrent.Executors;
-import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.atomic.AtomicReference;
 
-import com.fasterxml.jackson.databind.ObjectMapper;
-import org.junit.AfterClass;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.BeforeClass;
 import org.junit.Test;
 
-import com.vaadin.experimental.DisabledFeatureException;
 import com.vaadin.experimental.FeatureFlags;
 import com.vaadin.flow.dom.Element;
-import com.vaadin.flow.function.SerializableBiConsumer;
-import com.vaadin.flow.server.MockVaadinServletService;
+import com.vaadin.flow.internal.CurrentInstance;
+import com.vaadin.flow.server.VaadinService;
 import com.vaadin.flow.shared.Registration;
 import com.vaadin.signals.NumberSignal;
-import com.vaadin.signals.Signal;
-import com.vaadin.signals.SignalEnvironment;
 import com.vaadin.signals.ValueSignal;
 import com.vaadin.tests.util.MockUI;
 
 public class ComponentEffectTest {
-    private static final Executor executor = Runnable::run;
-    private static final ObjectMapper objectMapper = new ObjectMapper();
-
     @Test
     public void effect_componentAttachedAndDetached_effectEnabledAndDisabled() {
-        runWithSignalEnvironmentMocks(() -> {
+        runWithFeatureFlagEnabled(() -> {
             TestComponent component = new TestComponent();
             ValueSignal<String> signal = new ValueSignal<>("initial");
             AtomicInteger count = new AtomicInteger();
@@ -106,7 +84,7 @@ public void effect_componentAttachedAndDetached_effectEnabledAndDisabled() {
 
     @Test
     public void bind_signalValueChanges_componentUpdated() {
-        runWithSignalEnvironmentMocks(() -> {
+        runWithFeatureFlagEnabled(() -> {
             TestComponent component = new TestComponent();
             ValueSignal<String> signal = new ValueSignal<>("initial");
 
@@ -144,7 +122,7 @@ public void bind_signalValueChanges_componentUpdated() {
 
     @Test
     public void format_customLocale_signalValuesChange_formattedStringUpdated() {
-        runWithSignalEnvironmentMocks(() -> {
+        runWithFeatureFlagEnabled(() -> {
             TestComponent component = new TestComponent();
 
             MockUI ui = new MockUI();
@@ -187,7 +165,7 @@ public void format_customLocale_signalValuesChange_formattedStringUpdated() {
 
     @Test
     public void format_defaultLocale_signalValuesChange_formattedStringUpdated() {
-        runWithSignalEnvironmentMocks(() -> {
+        runWithFeatureFlagEnabled(() -> {
             TestComponent component = new TestComponent();
 
             MockUI ui = new MockUI();
@@ -204,31 +182,17 @@ public void format_defaultLocale_signalValuesChange_formattedStringUpdated() {
         });
     }
 
-    /**
-     * Other tests may already have initialized the environment with the feature
-     * flag off and executors that would throw an exception, so it's too late
-     * now to mock the feature flags. Thus we need to "reinitialize" the
-     * environment.
-     */
-    private static void runWithSignalEnvironmentMocks(Runnable test) {
-        try (var environment = mockStatic(SignalEnvironment.class);
-                var featureFlagStaticMock = mockStatic(FeatureFlags.class)) {
+    private static void runWithFeatureFlagEnabled(Runnable test) {
+        try (var featureFlagStaticMock = mockStatic(FeatureFlags.class)) {
             FeatureFlags flags = mock(FeatureFlags.class);
             when(flags.isEnabled(FeatureFlags.FLOW_FULLSTACK_SIGNALS.getId()))
                     .thenReturn(true);
             featureFlagStaticMock.when(() -> FeatureFlags.get(any()))
                     .thenReturn(flags);
-            environment.when(() -> SignalEnvironment.initialized())
-                    .thenReturn(true);
-            environment.when(() -> SignalEnvironment.defaultDispatcher())
-                    .thenReturn(executor);
-            environment.when(() -> SignalEnvironment.synchronousDispatcher())
-                    .thenReturn(executor);
-            environment.when(() -> SignalEnvironment.asynchronousDispatcher())
-                    .thenReturn(executor);
-            environment.when(() -> SignalEnvironment.objectMapper())
-                    .thenReturn(objectMapper);
             test.run();
+        } finally {
+            VaadinService.getCurrent().destroy();
+            CurrentInstance.clearAll();
         }
     }
 

flow-server/src/test/java/com/vaadin/flow/server/MockVaadinServletService.java

@@ -20,8 +20,6 @@
 import java.lang.reflect.Field;
 import java.util.Collections;
 import java.util.List;
-import java.util.concurrent.CopyOnWriteArrayList;
-import java.util.concurrent.atomic.AtomicReference;
 
 import org.mockito.Mockito;
 
@@ -168,15 +166,10 @@ public DeploymentConfiguration getDeploymentConfiguration() {
 
     private void resetSignalEnvironment() {
         try {
-            Field state = SignalEnvironment.class.getDeclaredField("state");
-            state.setAccessible(true);
-            ((AtomicReference<?>) state.get(null)).set(null);
-
-            Field dispatcherOverrides = SignalEnvironment.class
-                    .getDeclaredField("dispatcherOverrides");
-            dispatcherOverrides.setAccessible(true);
-            ((List<?>) dispatcherOverrides.get(null)).clear();
-
+            Field environments = SignalEnvironment.class
+                    .getDeclaredField("environments");
+            environments.setAccessible(true);
+            ((List<?>) environments.get(null)).clear();
         } catch (Exception e) {
             throw new AssertionError("Failed to reset Signal environment", e);
         }