@Override public void testReplaceExpiredEntry() throws Exception { cl.write(marshalledEntry(internalCacheEntry("k1", "v1", 100l))); timeService.advance(1101); assertNull(cl.load("k1")); long start = System.currentTimeMillis(); cl.write(marshalledEntry(internalCacheEntry("k1", "v2", 100l))); assertTrue(cl.load("k1").getValue().equals("v2") || TestingUtil.moreThanDurationElapsed(start, 100)); } }
public void testWriteAndDeleteBatch() throws Exception { // Number of entries is randomized to even numbers between 80 and 120 int numberOfEntries = 2 * ThreadLocalRandom.current().nextInt(WRITE_DELETE_BATCH_MIN_ENTRIES / 2, WRITE_DELETE_BATCH_MAX_ENTRIES / 2 + 1); assertIsEmpty(); assertNull("should not be present in the store", cl.load(0)); List<MarshalledEntry<?, ?>> entries = IntStream.range(0, numberOfEntries).boxed() .map(i -> marshalledEntry(i.toString(), "Val" + i, null)) .collect(Collectors.toList()); cl.writeBatch(entries); Set<MarshalledEntry<Object, Object>> set = TestingUtil.allEntries(cl); assertSize(set, numberOfEntries); assertNotNull(cl.load("56")); int batchSize = numberOfEntries / 2; List<Object> keys = IntStream.range(0, batchSize).mapToObj(Integer::toString).collect(Collectors.toList()); cl.deleteBatch(keys); set = TestingUtil.allEntries(cl); assertSize(set, batchSize); assertNull(cl.load("20")); }
assertExpired(se4, false); cl.write(marshalledEntry(se1)); cl.write(marshalledEntry(se2)); cl.write(marshalledEntry(se3)); cl.write(marshalledEntry(se4)); assertExpired(se4, true); cl.stop(); cl.start(); assertExpired(se1, true); assertNull(cl.load("k1")); assertContains("k1", false); assertExpired(se2, false); assertNotNull(cl.load("k2")); assertContains("k2", true); assertEquals("v2", unwrap(cl.load("k2").getValue())); assertExpired(se3, true); assertNull(cl.load("k3")); assertContains("k3", false); assertExpired(se4, true); assertNull(cl.load("k4")); assertContains("k4", false);
/** * When trying to persist an unsupported object an exception is expected. */ public void persistUnsupportedObject() throws Exception { try { cacheStore.write(new MarshalledEntryImpl("key", "value", null, marshaller)); fail("exception is expected as PersonKey2StringMapper does not support strings"); } catch (UnsupportedKeyTypeException e) { //expected } //just check that an person object will be persisted okay cacheStore.write(new MarshalledEntryImpl(MIRCEA, "Cluj Napoca", null, marshaller)); }
public void testStoreLoadRemove() throws Exception { assertRowCount(0); assertNull("should not be present in the store", cacheStore.load(MIRCEA)); String value = "adsdsadsa"; cacheStore.write(new MarshalledEntryImpl(MIRCEA, value, null, marshaller)); assertRowCount(1); assertEquals(value, cacheStore.load(MIRCEA).getValue()); assertFalse(cacheStore.delete(MANIK)); assertEquals(value, cacheStore.load(MIRCEA).getValue()); assertRowCount(1); assertTrue(cacheStore.delete(MIRCEA)); assertRowCount(0); }
public void testLoadAndStoreBytesValues() throws PersistenceException, IOException, InterruptedException { assertIsEmpty(); WrappedBytes key = new WrappedByteArray(getMarshaller().objectToByteBuffer(new Pojo().role("key"))); WrappedBytes key2 = new WrappedByteArray(getMarshaller().objectToByteBuffer(new Pojo().role("key2"))); WrappedBytes value = new WrappedByteArray(getMarshaller().objectToByteBuffer(new Pojo().role("value"))); assertFalse(cl.contains(key)); cl.write(new MarshalledEntryImpl<Object, Object>(key, value, null, getMarshaller())); assertEquals(value, cl.load(key).getValue()); MarshalledEntry entry = cl.load(key); assertTrue("Expected an immortalEntry", entry.getMetadata() == null || entry.getMetadata().expiryTime() == -1 || entry.getMetadata().maxIdle() == -1); assertContains(key, true); assertFalse(cl.delete(key2)); assertTrue(cl.delete(key)); }
public void testActivationOnGet(Method m) throws Exception { assertActivationCount(0); assert cache.get(k(m)) == null; assertActivationCount(0); loader.write(new MarshalledEntryImpl(k(m), v(m), null, marshaller())); assert loader.contains(k(m)); assert cache.get(k(m)).equals(v(m)); assertActivationCount(1); assert !loader.contains(k(m)); }
public void testPurgeExpired() throws Exception { InternalCacheEntry first = TestInternalCacheEntryFactory.create(MIRCEA, "val", 1000); InternalCacheEntry second = TestInternalCacheEntryFactory.create(MANIK, "val2"); cacheStore.write(marshalledEntry(first, marshaller)); cacheStore.write(marshalledEntry(second, marshaller)); assertRowCount(2); Thread.sleep(1100); cacheStore.purge(new WithinThreadExecutor(), null); assertRowCount(1); assertEquals("val2", cacheStore.load(MANIK).getValue()); }
public void testStoreAndRemove() throws PersistenceException { assertIsEmpty(); cl.write(marshalledEntry("k1", "v1", null)); cl.write(marshalledEntry("k2", "v2", null)); cl.write(marshalledEntry("k3", "v3", null)); cl.write(marshalledEntry("k4", "v4", null)); Set<MarshalledEntry<Object, Object>> set = TestingUtil.allEntries(cl); assertSize(set, 4); Set<String> expected = new HashSet<>(Arrays.asList("k1", "k2", "k3", "k4")); for (MarshalledEntry se : set) { assertTrue(expected.remove(se.getKey())); } assertEmpty(expected, true); cl.delete("k1"); cl.delete("k2"); cl.delete("k3"); set = TestingUtil.allEntries(cl); assertSize(set, 1); assertEquals("k4", set.iterator().next().getKey()); assertEquals(1, PersistenceUtil.toKeySet(cl, null).size()); assertEquals(1, Flowable.fromPublisher(cl.publishKeys(null)).count().blockingGet().intValue()); }
public void testPurgeListenerIsNotified() throws Exception { InternalCacheEntry first = TestInternalCacheEntryFactory.create(MIRCEA, "val", 1000); cacheStore.write(marshalledEntry(first, marshaller)); assertRowCount(1); Thread.sleep(1100); AdvancedCacheWriter.PurgeListener purgeListener = mock(AdvancedCacheWriter.PurgeListener.class); cacheStore.purge(new WithinThreadExecutor(), purgeListener); verify(purgeListener).entryPurged(MIRCEA); assertRowCount(0); } }
public void testLoadingToMemory() throws PersistenceException { assertNotInCacheAndStore("k1", "k2"); store.write(new MarshalledEntryImpl("k1", "v1", null, sm)); store.write(new MarshalledEntryImpl("k2", "v2", null, sm)); assertInStoreNotInCache("k1", "k2"); assertEquals("v1", cache.get("k1")); assertEquals("v2", cache.get("k2")); assertInCacheAndStore("k1", "v1"); assertInCacheAndStore("k2", "v2"); store.delete("k1"); store.delete("k2"); assertInCacheAndNotInStore("k1", "k2"); assertEquals("v1", cache.get("k1")); assertEquals("v2", cache.get("k2")); }
protected void assertEventuallyExpires(final String key) throws Exception { eventually(() -> cl.load(key) == null); }
protected final void assertContains(Object k, boolean expected) { assertEquals("contains(" + k + ")", expected, cl.contains(k)); }
@BeforeClass public void createCacheStore() throws PersistenceException { ConfigurationBuilder builder = TestCacheManagerFactory.getDefaultCacheConfiguration(false); JdbcStringBasedStoreConfigurationBuilder storeBuilder = createJdbcConfig(builder); UnitTestDatabaseManager.buildTableManipulation(storeBuilder.table()); UnitTestDatabaseManager.configureUniqueConnectionFactory(storeBuilder); cacheStore = new JdbcStringBasedStore(); marshaller = new TestObjectStreamMarshaller(); cacheStore.init(PersistenceMockUtil.createContext(getClass().getSimpleName(), builder.build(), marshaller)); cacheStore.start(); tableManager = (TableManager) ReflectionUtil.getValue(cacheStore, "tableManager"); }
@AfterClass public void destroyStore() throws PersistenceException { cacheStore.stop(); marshaller.stop(); }
@AfterMethod public void afterMethod() throws PersistenceException { if (cache != null) cache.clear(); if (store != null) store.clear(); }
@BeforeMethod(alwaysRun = true) public void setUp() throws Exception { marshaller = new TestObjectStreamMarshaller(); timeService = getTimeService(); factory = new InternalEntryFactoryImpl(); TestingUtil.inject(factory, timeService); try { //noinspection unchecked cl = createStore(); cl.start(); } catch (Exception e) { log.error("Error creating store", e); throw e; } }