package com.atlassian.cache.hazelcast;
   
   import java.util.concurrent.TimeUnit;
   
   import com.atlassian.cache.CacheSettings;
   import com.atlassian.cache.CacheSettingsBuilder;
   import com.atlassian.hazelcast.test.HazelcastCluster;
   
   import com.hazelcast.config.MapConfig;
  import com.hazelcast.core.HazelcastInstance;
  import com.hazelcast.map.impl.MapService;
  import com.hazelcast.spi.AbstractDistributedObject;
  
  import org.junit.After;
  import org.junit.Before;
  import org.junit.Rule;
  import org.junit.Test;
  
  import static org.junit.Assert.assertEquals;
  import static org.junit.Assert.assertNotNull;
  
  /**
   * Tests whether a cache configured on one node is configured identically across the cluster
   */
  public class CacheConfigReplicationTest
  {
      @Rule
      public final HazelcastCluster cluster = new HazelcastCluster.Builder()
              .size(2, 3)
              .build();
  
      private HazelcastCacheManager factory1;
      private HazelcastCacheManager factory2;
  
      @Before
      public void setup()
      {
          factory1 = HazelcastTestSupport.createDistributedFactory(cluster.getNode(0));
          factory2 = HazelcastTestSupport.createDistributedFactory(cluster.getNode(1));
      }
  
      @After
      public void tearDown()
      {
          factory1.destroy();
          factory2.destroy();
      }
  
      @Test
      public void testMapConfigReplication() throws InterruptedException
      {
          CacheSettings settings = new CacheSettingsBuilder().remote().expireAfterWrite(10, TimeUnit.SECONDS).build();
  
          // create the a cache on node1
          factory1.getCache("test-cache", null, settings);
  
          String mapName = HazelcastCacheManager.PREFIX_CACHE + "test-cache";
  
          // verify that the settings are applied to the IMap on node 1
          MapConfig config1 = getConfigForMap(cluster.getNode(0), mapName);
  
          assertNotNull(config1);
          assertEquals(mapName, config1.getName());
          assertEquals(10, config1.getTimeToLiveSeconds());
  
          Thread.sleep(500L); // give the join some time to succeed and potentially replicate the config
  
          // verify that the same MapConfig that is actually being used in the MapContainer has been applied on node 2
          MapConfig config2 = getConfigForMap(cluster.getNode(1), mapName);
  
          assertNotNull(config2);
          assertEquals(mapName, config2.getName());
          assertEquals(10, config2.getTimeToLiveSeconds());
      }
  
      @Test
      public void testMapConfigReplicationOnJoin() throws InterruptedException
      {
          CacheSettings settings = new CacheSettingsBuilder().remote().expireAfterWrite(20, TimeUnit.SECONDS).build();
  
          // create a Cache on node1
          factory1.getCache("test-cache", null, settings);
  
          // add a new node and verify that the IMap is created with the correct settings on the node
          HazelcastInstance node3 = cluster.addNode();
  
          // create the cacheFactory on node 3 as well
          HazelcastCacheManager factory3 = HazelcastTestSupport.createDistributedFactory(node3);
  
          // verify that the same MapConfig that is actually being used in the MapContainer has been applied on node 2
          String mapName = HazelcastCacheManager.PREFIX_CACHE + "test-cache";
          MapConfig config3 = getConfigForMap(node3, mapName);
          assertNotNull(config3);
          assertEquals(mapName, config3.getName());
          assertEquals(20, config3.getTimeToLiveSeconds());
  
          factory3.destroy();
      }
  
     private MapConfig getConfigForMap(HazelcastInstance hazelcast, String mapName)
     {
         AbstractDistributedObject map = hazelcast.getDistributedObject(MapService.SERVICE_NAME, mapName);
         MapService mapService = (MapService) map.getService();
         return mapService.getMapServiceContext().getMapContainer(mapName).getMapConfig();
     }
 }