Fix non-root namespace bean

  injection timing issue (#2579)

Author: expanded-for-real

temporal-spring-boot-autoconfigure/src/main/java/io/temporal/spring/boot/autoconfigure/NonRootBeanPostProcessor.java

@@ -43,41 +43,41 @@ public class NonRootBeanPostProcessor implements BeanPostProcessor, BeanFactoryA
   private static final Logger log = LoggerFactory.getLogger(NonRootBeanPostProcessor.class);
 
   private ConfigurableListableBeanFactory beanFactory;
+  private boolean beansCreated = false;
 
   private final @Nonnull TemporalProperties temporalProperties;
-  private final @Nullable List<NonRootNamespaceProperties> namespaceProperties;
   private @Nullable Tracer tracer;
   private @Nullable TestWorkflowEnvironmentAdapter testWorkflowEnvironment;
   private @Nullable Scope metricsScope;
 
   public NonRootBeanPostProcessor(@Nonnull TemporalProperties temporalProperties) {
     this.temporalProperties = temporalProperties;
-    this.namespaceProperties = temporalProperties.getNamespaces();
   }
 
   @Override
   public Object postProcessAfterInitialization(@Nonnull Object bean, @Nonnull String beanName)
       throws BeansException {
     if (bean instanceof NamespaceTemplate && beanName.equals("temporalRootNamespaceTemplate")) {
-      if (namespaceProperties != null) {
-        // If there are non-root namespaces, we need to inject beans for each of them. Look
-        // up the bean manually instead of using @Autowired to avoid circular dependencies or
-        // causing the dependency to
-        // get initialized to early and skip post-processing.
-        //
-        // Note: We don't use @Lazy here because these dependencies are optional and @Lazy doesn't
-        // interact well with
-        // optional dependencies.
-        metricsScope = findBean("temporalMetricsScope", Scope.class);
-        tracer = findBean(Tracer.class);
-        testWorkflowEnvironment =
-            findBean("temporalTestWorkflowEnvironment", TestWorkflowEnvironmentAdapter.class);
-        namespaceProperties.forEach(this::injectBeanByNonRootNamespace);
+      if (!beansCreated) {
+        createNonRootNamespaceBeans();
+        beansCreated = true;
       }
     }
     return bean;
   }
 
+  private void createNonRootNamespaceBeans() {
+    List<NonRootNamespaceProperties> namespaces = temporalProperties.getNamespaces();
+    if (namespaces != null) {
+      // Look up dependencies that might not be available at bean definition time
+      metricsScope = findBean("temporalMetricsScope", Scope.class);
+      tracer = findBean(Tracer.class);
+      testWorkflowEnvironment =
+          findBean("temporalTestWorkflowEnvironment", TestWorkflowEnvironmentAdapter.class);
+      namespaces.forEach(this::injectBeanByNonRootNamespace);
+    }
+  }
+
   private void injectBeanByNonRootNamespace(NonRootNamespaceProperties ns) {
     String beanPrefix = MoreObjects.firstNonNull(ns.getAlias(), ns.getNamespace());
     DataConverter dataConverterByNamespace = findBeanByNamespace(beanPrefix, DataConverter.class);

temporal-spring-boot-autoconfigure/src/test/java/io/temporal/spring/boot/autoconfigure/NonRootBeanPostProcessorTest.java

@@ -0,0 +1,86 @@
+package io.temporal.spring.boot.autoconfigure;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.when;
+
+import io.temporal.spring.boot.autoconfigure.properties.TemporalProperties;
+import io.temporal.spring.boot.autoconfigure.template.NamespaceTemplate;
+import java.util.Collections;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
+
+@ExtendWith(MockitoExtension.class)
+public class NonRootBeanPostProcessorTest {
+
+  @Mock private TemporalProperties temporalProperties;
+  @Mock private ConfigurableListableBeanFactory beanFactory;
+  @Mock private NamespaceTemplate rootNamespaceTemplate;
+
+  private NonRootBeanPostProcessor processor;
+
+  @BeforeEach
+  void setUp() {
+    processor = new NonRootBeanPostProcessor(temporalProperties);
+    processor.setBeanFactory(beanFactory);
+  }
+
+  @Test
+  void shouldNotProcessBeansWhenNoNamespaces() {
+    when(temporalProperties.getNamespaces()).thenReturn(null);
+    Object result =
+        processor.postProcessAfterInitialization(
+            rootNamespaceTemplate, "temporalRootNamespaceTemplate");
+    assertThat(result).isSameAs(rootNamespaceTemplate);
+  }
+
+  @Test
+  void shouldNotProcessBeansWhenEmptyNamespaces() {
+    when(temporalProperties.getNamespaces()).thenReturn(Collections.emptyList());
+    Object result =
+        processor.postProcessAfterInitialization(
+            rootNamespaceTemplate, "temporalRootNamespaceTemplate");
+    assertThat(result).isSameAs(rootNamespaceTemplate);
+  }
+
+  @Test
+  void shouldOnlyProcessRootNamespaceTemplate() {
+    Object otherBean = new Object();
+    Object result = processor.postProcessAfterInitialization(otherBean, "someOtherBean");
+    assertThat(result).isSameAs(otherBean);
+  }
+
+  @Test
+  void shouldProcessOnlyOnceEvenWithMultipleCalls() {
+    when(temporalProperties.getNamespaces()).thenReturn(Collections.emptyList());
+    Object result1 =
+        processor.postProcessAfterInitialization(
+            rootNamespaceTemplate, "temporalRootNamespaceTemplate");
+    Object result2 =
+        processor.postProcessAfterInitialization(
+            rootNamespaceTemplate, "temporalRootNamespaceTemplate");
+    assertThat(result1).isSameAs(rootNamespaceTemplate);
+    assertThat(result2).isSameAs(rootNamespaceTemplate);
+  }
+
+  @Test
+  void shouldReturnOriginalBeanUnchanged() {
+    when(temporalProperties.getNamespaces()).thenReturn(Collections.emptyList());
+    Object result =
+        processor.postProcessAfterInitialization(
+            rootNamespaceTemplate, "temporalRootNamespaceTemplate");
+    assertThat(result).isSameAs(rootNamespaceTemplate);
+  }
+
+  @Test
+  void shouldHandleNullNamespaceGracefully() {
+    when(temporalProperties.getNamespaces()).thenReturn(null);
+    Object result =
+        processor.postProcessAfterInitialization(
+            rootNamespaceTemplate, "temporalRootNamespaceTemplate");
+    assertThat(result).isSameAs(rootNamespaceTemplate);
+  }
+}

temporal-spring-boot-autoconfigure/src/test/java/io/temporal/spring/boot/autoconfigure/NonRootNamespaceBeanAvailabilityTest.java

@@ -0,0 +1,69 @@
+package io.temporal.spring.boot.autoconfigure;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
+import org.junit.jupiter.api.Timeout;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.context.ConfigurableApplicationContext;
+import org.springframework.test.context.ActiveProfiles;
+
+@SpringBootTest(classes = NonRootNamespaceBeanAvailabilityTest.Configuration.class)
+@ActiveProfiles(profiles = "multi-namespaces")
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+public class NonRootNamespaceBeanAvailabilityTest {
+
+  @Autowired ConfigurableApplicationContext applicationContext;
+
+  @BeforeEach
+  void setUp() {
+    applicationContext.start();
+  }
+
+  @Test
+  @Timeout(value = 10)
+  public void shouldRegisterNonRootNamespaceBeansInContext() {
+    assertThat(applicationContext.containsBean("ns1WorkflowClient")).isTrue();
+    assertThat(applicationContext.containsBean("namespace2WorkflowClient")).isTrue();
+    assertThat(applicationContext.containsBean("ns1ScheduleClient")).isTrue();
+    assertThat(applicationContext.containsBean("namespace2ScheduleClient")).isTrue();
+    assertThat(applicationContext.containsBean("ns1WorkerFactory")).isTrue();
+    assertThat(applicationContext.containsBean("namespace2WorkerFactory")).isTrue();
+  }
+
+  @Test
+  @Timeout(value = 10)
+  public void shouldRegisterNonRootNamespaceTemplateBeansInContext() {
+    assertThat(applicationContext.containsBean("ns1NamespaceTemplate")).isTrue();
+    assertThat(applicationContext.containsBean("namespace2NamespaceTemplate")).isTrue();
+    assertThat(applicationContext.containsBean("ns1ClientTemplate")).isTrue();
+    assertThat(applicationContext.containsBean("namespace2ClientTemplate")).isTrue();
+    assertThat(applicationContext.containsBean("ns1WorkersTemplate")).isTrue();
+    assertThat(applicationContext.containsBean("namespace2WorkersTemplate")).isTrue();
+  }
+
+  @Test
+  @Timeout(value = 10)
+  public void shouldHaveBeansAvailableForLookup() {
+    assertThat(applicationContext.getBean("ns1WorkflowClient")).isNotNull();
+    assertThat(applicationContext.getBean("namespace2WorkflowClient")).isNotNull();
+    assertThat(applicationContext.getBean("ns1ScheduleClient")).isNotNull();
+    assertThat(applicationContext.getBean("namespace2ScheduleClient")).isNotNull();
+    assertThat(applicationContext.getBean("ns1WorkerFactory")).isNotNull();
+    assertThat(applicationContext.getBean("namespace2WorkerFactory")).isNotNull();
+  }
+
+  @Test
+  @Timeout(value = 10)
+  public void applicationContextStartsSuccessfully() {
+    assertThat(applicationContext.isRunning()).isTrue();
+    assertThat(applicationContext.isActive()).isTrue();
+  }
+
+  @EnableAutoConfiguration
+  public static class Configuration {}
+}