Add Integration Tests for the EnableGemFireInitializationSafety annotation and GemFireInitializationSafetyConfiguration class using GatewayReceivers.

Resolves spring-projectsgh-554.

Author: jxblum

spring-data-geode/src/test/java/org/springframework/data/gemfire/config/annotation/EnableGemFireInitializationSafetyConfigurationWithWanGatewayIntegrationTests.java

@@ -0,0 +1,163 @@
+/*
+ * Copyright 2021 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.gemfire.config.annotation;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import java.util.Optional;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.jupiter.api.Order;
+import org.junit.runner.RunWith;
+import org.mockito.InOrder;
+
+import org.apache.geode.cache.Cache;
+import org.apache.geode.cache.GemFireCache;
+import org.apache.geode.cache.wan.GatewayReceiver;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.context.annotation.Bean;
+import org.springframework.data.gemfire.GemfireUtils;
+import org.springframework.data.gemfire.LocalRegionFactoryBean;
+import org.springframework.data.gemfire.PartitionedRegionFactoryBean;
+import org.springframework.data.gemfire.ReplicatedRegionFactoryBean;
+import org.springframework.data.gemfire.tests.mock.annotation.EnableGemFireMockObjects;
+import org.springframework.data.gemfire.wan.GatewayReceiverFactoryBean;
+import org.springframework.data.gemfire.wan.support.InitializationSafeGatewayReceiver;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringRunner;
+
+/**
+ * Integration Tests for {@link EnableGemFireInitializationSafety} annotation
+ * and the {@link GemFireInitializationSafetyConfiguration} class.
+ *
+ * @author John Blum
+ * @see org.junit.Test
+ * @see org.mockito.Mockito
+ * @see org.springframework.data.gemfire.config.annotation.EnableGemFireInitializationSafety
+ * @see org.springframework.data.gemfire.config.annotation.GemFireInitializationSafetyConfiguration
+ * @see org.springframework.test.context.ContextConfiguration
+ * @see org.springframework.test.context.junit4.SpringRunner
+ * @since 2.7.0
+ */
+@RunWith(SpringRunner.class)
+@ContextConfiguration
+@SuppressWarnings("unused")
+public class EnableGemFireInitializationSafetyConfigurationWithWanGatewayIntegrationTests {
+
+	@Autowired
+	private Cache cache;
+
+	@Autowired
+	private GatewayReceiver gatewayReceiver;
+
+	@Autowired
+	@Qualifier("&GatewayReceiver")
+	private GatewayReceiverFactoryBean gatewayReceiverFactoryBean;
+
+	@Before
+	public void assertCacheConfiguration() {
+
+		assertThat(this.cache).isNotNull();
+		assertThat(this.cache.getName())
+			.isEqualTo(EnableGemFireInitializationSafetyConfigurationWithWanGatewayIntegrationTests.class.getSimpleName());
+		assertThat(this.cache.rootRegions()).hasSize(3);
+		assertThat(this.cache.getGatewayReceivers()).hasSize(1);
+		assertThat(this.gatewayReceiverFactoryBean).isNotNull();
+		assertThat(this.gatewayReceiverFactoryBean.isManualStart()).isTrue();
+		assertThat(this.gatewayReceiver).isInstanceOf(InitializationSafeGatewayReceiver.class);
+		assertThat(this.gatewayReceiver.isManualStart()).isTrue();
+	}
+
+	@Test
+	public void cacheRegionsInitializedBeforeGatewayReceiverStart() throws Exception {
+
+		GatewayReceiver unwrappedMockGatewayReceiver = Optional.of(this.gatewayReceiver)
+			.filter(InitializationSafeGatewayReceiver.class::isInstance)
+			.map(InitializationSafeGatewayReceiver.class::cast)
+			.map(InitializationSafeGatewayReceiver::getDelegate)
+			.orElse(this.gatewayReceiver);
+
+		InOrder order = inOrder(this.cache, this.gatewayReceiverFactoryBean, unwrappedMockGatewayReceiver);
+
+		order.verify(this.gatewayReceiverFactoryBean, times(1)).setManualStart(eq(true));
+		order.verify(this.cache, times(2)).rootRegions();
+		verify(this.cache, times(1)).getRegion(GemfireUtils.toRegionPath("LocalRegion"));
+		verify(this.cache, times(1)).getRegion(GemfireUtils.toRegionPath("PartitionRegion"));
+		verify(this.cache, times(1)).getRegion(GemfireUtils.toRegionPath("ReplicateRegion"));
+		order.verify(unwrappedMockGatewayReceiver, times(1)).start();
+	}
+
+	@PeerCacheApplication(name = "EnableGemFireInitializationSafetyConfigurationWithWanGatewayIntegrationTests")
+	@EnableGemFireInitializationSafety
+	@EnableGemFireMockObjects
+	static class TestConfiguration {
+
+		@Order(2)
+		@Bean("LocalRegion")
+		LocalRegionFactoryBean<Object, Object> localRegion(GemFireCache gemfireCache) {
+
+			LocalRegionFactoryBean<Object, Object> localRegionFactory = new LocalRegionFactoryBean<>();
+
+			localRegionFactory.setCache(gemfireCache);
+			localRegionFactory.setPersistent(false);
+
+			return localRegionFactory;
+		}
+
+		@Order(3)
+		@Bean("PartitionRegion")
+		PartitionedRegionFactoryBean<Object, Object> partitionRegion(GemFireCache gemfireCache) {
+
+			PartitionedRegionFactoryBean<Object, Object> partitionRegionFactory = new PartitionedRegionFactoryBean<>();
+
+			partitionRegionFactory.setCache(gemfireCache);
+			partitionRegionFactory.setPersistent(false);
+
+			return partitionRegionFactory;
+		}
+
+		@Order(4)
+		@Bean("ReplicateRegion")
+		ReplicatedRegionFactoryBean<Object, Object> replicateRegion(GemFireCache gemfireCache) {
+
+			ReplicatedRegionFactoryBean<Object, Object> replicateRegionFactory = new ReplicatedRegionFactoryBean<>();
+
+			replicateRegionFactory.setCache(gemfireCache);
+			replicateRegionFactory.setPersistent(false);
+
+			return replicateRegionFactory;
+		}
+
+		@Order(1)
+		@Bean("GatewayReceiver")
+		GatewayReceiverFactoryBean gatewayReceiverBean(Cache peerCache) {
+
+			GatewayReceiverFactoryBean gatewayReceiverFactory = new GatewayReceiverFactoryBean(peerCache);
+
+			gatewayReceiverFactory.setManualStart(false);
+
+			return spy(gatewayReceiverFactory);
+		}
+	}
+}