@NotNull @Override public List<Record> apply(@NotNull Collection<Record> records) { final List<Record> result = new ArrayList<>(records.size()); for (Record record : records) { result.add(record.toBuilder().mutationId(request.uniqueId).build()); } return result; } }
@Override public void didResolve(ResponseField field, Operation.Variables variables) { path.remove(path.size() - 1); Object value = valueStack.pop(); String cacheKey = cacheKeyBuilder().build(field, variables); String dependentKey = currentRecordBuilder.key() + "." + cacheKey; dependentKeys.add(dependentKey); currentRecordBuilder.addField(cacheKey, value); if (recordStack.isEmpty()) { recordSet.merge(currentRecordBuilder.build()); } }
@Override public void willResolveObject(ResponseField field, Optional<R> objectSource) { pathStack.push(path); CacheKey cacheKey = objectSource.isPresent() ? resolveCacheKey(field, objectSource.get()) : CacheKey.NO_KEY; String cacheKeyValue = cacheKey.key(); if (cacheKey.equals(CacheKey.NO_KEY)) { cacheKeyValue = pathToString(); } else { path = new ArrayList<>(); path.add(cacheKeyValue); } recordStack.push(currentRecordBuilder.build()); currentRecordBuilder = Record.builder(cacheKeyValue); }
@Override public void didResolveObject(ResponseField field, Optional<R> objectSource) { path = pathStack.pop(); if (objectSource.isPresent()) { Record completedRecord = currentRecordBuilder.build(); valueStack.push(new CacheReference(completedRecord.key())); dependentKeys.add(completedRecord.key()); recordSet.merge(completedRecord); } currentRecordBuilder = recordStack.pop().toBuilder(); }
@Override public void didResolve(ResponseField field, Operation.Variables variables) { path.remove(path.size() - 1); Object value = valueStack.pop(); String cacheKey = field.cacheKey(variables); String dependentKey = currentRecordBuilder.key() + "." + cacheKey; dependentKeys.add(dependentKey); currentRecordBuilder.addField(cacheKey, value); if (recordStack.isEmpty()) { recordSet.merge(currentRecordBuilder.build()); } }
@Nonnull @Override public List<Record> apply(@Nonnull Collection<Record> records) { final List<Record> result = new ArrayList<>(records.size()); for (Record record : records) { result.add(record.toBuilder().mutationId(request.uniqueId).build()); } return result; } }
@Override public void willResolveObject(ResponseField field, Optional<R> objectSource) { pathStack.push(path); CacheKey cacheKey = objectSource.isPresent() ? resolveCacheKey(field, objectSource.get()) : CacheKey.NO_KEY; String cacheKeyValue = cacheKey.key(); if (cacheKey == CacheKey.NO_KEY) { cacheKeyValue = pathToString(); } else { path = new ArrayList<>(); path.add(cacheKeyValue); } recordStack.push(currentRecordBuilder.build()); currentRecordBuilder = Record.builder(cacheKeyValue); }
recordBuilder.addField("listOfScalarList", expectedListOfScalarList); recordBuilder.addField("map", expectedMap); Record record = recordBuilder.build();
@Test public void testEviction() { LruNormalizedCache lruCache = new LruNormalizedCacheFactory(EvictionPolicy.builder().maxSizeBytes(2000) .build()).create(basicFieldAdapter); Record.Builder testRecord1Builder = Record.builder("key1"); testRecord1Builder.addField("a", new String(new byte[1100], Charset.defaultCharset())); Record testRecord1 = testRecord1Builder.build(); Record.Builder testRecord2Builder = Record.builder("key2"); testRecord2Builder.addField("a", new String(new byte[1100], Charset.defaultCharset())); Record testRecord2 = testRecord2Builder.build(); Record.Builder testRecord3Builder = Record.builder("key3"); testRecord3Builder.addField("a", new String(new byte[10], Charset.defaultCharset())); Record testRecord3 = testRecord3Builder.build(); List<Record> records = Arrays.asList( testRecord1, testRecord2, testRecord3 ); lruCache.merge(records, CacheHeaders.NONE); //Cache does not reveal exactly how it handles eviction, but appears //to evict more than is strictly necessary. Regardless, any sane eviction //strategy should leave the third record in this test case, and evict the first record. assertThat(lruCache.loadRecord("key1", CacheHeaders.NONE)).isNull(); assertThat(lruCache.loadRecord("key3", CacheHeaders.NONE)).isNotNull(); }
@Test public void testDualCacheMultipleRecord() { LruNormalizedCacheFactory secondaryCacheFactory = new LruNormalizedCacheFactory(EvictionPolicy.NO_EVICTION); NormalizedCache primaryCache = new LruNormalizedCacheFactory(EvictionPolicy.NO_EVICTION) .chain(secondaryCacheFactory).createChain(basicFieldAdapter); Record.Builder recordBuilder = Record.builder("root1"); recordBuilder.addField("bar", "bar"); final Record record1 = recordBuilder.build(); recordBuilder = Record.builder("root2"); recordBuilder.addField("bar", "bar"); final Record record2 = recordBuilder.build(); recordBuilder = Record.builder("root3"); recordBuilder.addField("bar", "bar"); final Record record3 = recordBuilder.build(); Collection<Record> records = Arrays.asList(record1, record2, record3); Collection<String> keys = Arrays.asList(record1.key(), record2.key(), record3.key()); primaryCache.merge(records, CacheHeaders.NONE); assertThat(primaryCache.loadRecords(keys, CacheHeaders.NONE).size()).isEqualTo(3); //verify write through behavior assertThat(primaryCache.loadRecords(keys, CacheHeaders.NONE).size()).isEqualTo(3); assertThat(primaryCache.nextCache().get() .loadRecords(keys, CacheHeaders.NONE).size()).isEqualTo(3); }
@Test public void testRecordWeigher() { Record.Builder recordBuilder = Record.builder("root"); BigDecimal expectedBigDecimal = new BigDecimal(1.23); String expectedStringValue = "StringValue"; Boolean expectedBooleanValue = true; CacheReference expectedCacheReference = new CacheReference("foo"); List<CacheReference> expectedCacheReferenceList = Arrays.asList(new CacheReference("bar"), new CacheReference ("baz")); List<Object> expectedScalarList = Arrays.<Object>asList("scalarOne", "scalarTwo"); recordBuilder.addField("bigDecimal", expectedBigDecimal); recordBuilder.addField("string", expectedStringValue); recordBuilder.addField("boolean", expectedBooleanValue); recordBuilder.addField("cacheReference", expectedCacheReference); recordBuilder.addField("scalarList", expectedScalarList); recordBuilder.addField("referenceList", expectedCacheReferenceList); Record record = recordBuilder.build(); record.sizeEstimateBytes(); //It's difficult to say what the "right" size estimate is, so just checking it is has been calculate at all. assertThat(record.sizeEstimateBytes()).isNotEqualTo(-1); } }
@Override public Set<String> execute(WriteableStore cache) { RealResponseWriter responseWriter = new RealResponseWriter(operation.variables(), scalarTypeAdapters); operationData.marshaller().marshal(responseWriter); ResponseNormalizer<Map<String, Object>> responseNormalizer = networkResponseNormalizer(); responseNormalizer.willResolveRootQuery(operation); responseWriter.resolveFields(responseNormalizer); if (optimistic) { List<Record> updatedRecords = new ArrayList<>(); for (Record record : responseNormalizer.records()) { updatedRecords.add(record.toBuilder().mutationId(mutationId).build()); } return optimisticCache.mergeOptimisticUpdates(updatedRecords); } else { return optimisticCache.merge(responseNormalizer.records(), CacheHeaders.NONE); } } });
@Test public void testClearPrimaryCache() { LruNormalizedCacheFactory secondaryCacheFactory = new LruNormalizedCacheFactory(EvictionPolicy.NO_EVICTION); LruNormalizedCache primaryCache = (LruNormalizedCache) new LruNormalizedCacheFactory(EvictionPolicy.NO_EVICTION) .chain(secondaryCacheFactory).createChain(basicFieldAdapter); Record record = Record.builder("key").build(); primaryCache.merge(record, CacheHeaders.NONE); primaryCache.clearCurrentCache(); assertThat(primaryCache.nextCache().get() .loadRecord("key", CacheHeaders.NONE)).isNotNull(); assertThat(primaryCache.nextCache().get() .loadRecord("key", CacheHeaders.NONE)).isNotNull(); }
@Test public void testDualCacheSingleRecord() { LruNormalizedCacheFactory secondaryCacheFactory = new LruNormalizedCacheFactory(EvictionPolicy.NO_EVICTION); NormalizedCache primaryCache = new LruNormalizedCacheFactory(EvictionPolicy.NO_EVICTION) .chain(secondaryCacheFactory).createChain(basicFieldAdapter); Record.Builder recordBuilder = Record.builder("root"); recordBuilder.addField("bar", "bar"); final Record record = recordBuilder.build(); primaryCache.merge(record, CacheHeaders.NONE); //verify write through behavior assertThat(primaryCache.loadRecord("root", CacheHeaders.NONE).field("bar")).isEqualTo("bar"); assertThat(primaryCache.nextCache().get().loadRecord("root", CacheHeaders.NONE).field("bar")).isEqualTo("bar"); }
@Override public Record clone() { return toBuilder().build(); }
@Test public void testClearAll() { LruNormalizedCacheFactory secondaryCacheFactory = new LruNormalizedCacheFactory(EvictionPolicy.NO_EVICTION); NormalizedCache primaryCacheStore = new LruNormalizedCacheFactory(EvictionPolicy.NO_EVICTION) .chain(secondaryCacheFactory).createChain(basicFieldAdapter); Record record = Record.builder("key").build(); primaryCacheStore.merge(record, CacheHeaders.NONE); primaryCacheStore.clearAll(); assertThat(primaryCacheStore.loadRecord("key", CacheHeaders.NONE)).isNull(); }
@Override public void didResolveObject(ResponseField field, Optional<R> objectSource) { path = pathStack.pop(); if (objectSource.isPresent()) { Record completedRecord = currentRecordBuilder.build(); valueStack.push(new CacheReference(completedRecord.key())); dependentKeys.add(completedRecord.key()); recordSet.merge(completedRecord); } currentRecordBuilder = recordStack.pop().toBuilder(); }
private Record createTestRecord(String id) { Record.Builder testRecord = Record.builder("key" + id); testRecord.addField("a", "stringValueA" + id); testRecord.addField("b", "stringValueB" + id); return testRecord.build(); } }
@Test public void testClearSecondaryCache() { LruNormalizedCacheFactory secondaryCacheFactory = new LruNormalizedCacheFactory(EvictionPolicy.NO_EVICTION); NormalizedCache primaryCache = new LruNormalizedCacheFactory(EvictionPolicy.NO_EVICTION) .chain(secondaryCacheFactory).createChain(basicFieldAdapter); Record record = Record.builder("key").build(); primaryCache.merge(record, CacheHeaders.NONE); primaryCache.nextCache().get().clearAll(); assertThat(primaryCache.nextCache().get().loadRecord("key", CacheHeaders.NONE)).isNull(); }