AbstractTwoCachesExpirationTest.java

package org.infinispan.jcache;

import static org.infinispan.jcache.util.JCacheTestingUtil.sleep;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertNull;

import java.io.Serializable;
import java.lang.reflect.Method;
import java.util.concurrent.atomic.AtomicInteger;

import javax.cache.Cache;
import javax.cache.configuration.FactoryBuilder;
import javax.cache.configuration.MutableCacheEntryListenerConfiguration;
import javax.cache.event.CacheEntryExpiredListener;
import javax.cache.event.CacheEntryListenerException;

import org.infinispan.test.MultipleCacheManagersTest;
import org.infinispan.util.ControlledTimeService;
import org.testng.annotations.Test;

/**
 * Base class for clustered JCache expiration tests. Implementations must provide cache references.
 *
 * @author Matej Cimbora
 */
@Test(testName = "org.infinispan.jcache.AbstractTwoCachesExpirationTest", groups = "functional")
public abstract class AbstractTwoCachesExpirationTest extends MultipleCacheManagersTest {

   protected final ControlledTimeService controlledTimeService = new ControlledTimeService();
   protected static final int EXPIRATION_TIMEOUT = 1000;

   @Test
   public void testExpiration(Method m) {
      Cache<String, String> cache1 = getCache1(m);
      Cache<String, String> cache2 = getCache2(m);

      TestExpiredListener listener = new TestExpiredListener();
      MutableCacheEntryListenerConfiguration conf1 = new MutableCacheEntryListenerConfiguration(FactoryBuilder.factoryOf(listener), null, false, false);
      cache1.registerCacheEntryListener(conf1);
      cache2.put("key1", "val1");
      controlledTimeService.advance(EXPIRATION_TIMEOUT + 1000);
      eventually(() -> listener.invocationCount.get() >0);
      assertNull(cache1.get("key1"));

      listener.invocationCount.set(0);
      cache1.deregisterCacheEntryListener(conf1);
      cache2.put("key2", "val2");
      controlledTimeService.advance(EXPIRATION_TIMEOUT + 1000);
      assertNull(cache1.get("key2"));
      sleep(EXPIRATION_TIMEOUT);
      assertEquals(listener.invocationCount.get(), 0);
   }

   private static class TestExpiredListener implements CacheEntryExpiredListener, Serializable {

      private final AtomicInteger invocationCount = new AtomicInteger(0);

      @Override
      public void onExpired(Iterable iterable) throws CacheEntryListenerException {
         iterable.forEach(e -> invocationCount.incrementAndGet());
      }
   }

   public abstract Cache getCache1(Method m);
   public abstract Cache getCache2(Method m);
}