From d9cef737e33e968562c0a4ca072e0ab57fbcc7b6 Mon Sep 17 00:00:00 2001 From: rbygrave Date: Wed, 1 Sep 2021 09:02:01 +1200 Subject: [PATCH 1/3] #2335 Initial test work --- .../model/basic/cache/ESoftWithCache.java | 69 +++++++++++++++++++ .../basic/cache/TestCacheWithSoftDelete.java | 34 +++++++++ 2 files changed, 103 insertions(+) create mode 100644 ebean-core/src/test/java/org/tests/model/basic/cache/ESoftWithCache.java create mode 100644 ebean-core/src/test/java/org/tests/model/basic/cache/TestCacheWithSoftDelete.java diff --git a/ebean-core/src/test/java/org/tests/model/basic/cache/ESoftWithCache.java b/ebean-core/src/test/java/org/tests/model/basic/cache/ESoftWithCache.java new file mode 100644 index 000000000..d570e1e4a --- /dev/null +++ b/ebean-core/src/test/java/org/tests/model/basic/cache/ESoftWithCache.java @@ -0,0 +1,69 @@ +package org.tests.model.basic.cache; + +import io.ebean.Model; +import io.ebean.annotation.Cache; +import io.ebean.annotation.SoftDelete; + +import javax.persistence.Entity; +import javax.persistence.Id; +import javax.persistence.Table; +import javax.persistence.Version; + +@Cache +@Entity +@Table(name = "e_softwithcache") +public class ESoftWithCache extends Model { + + @Id + long id; + + String name; + + String description; + + @SoftDelete + boolean deleted; + + @Version + long version; + + public ESoftWithCache(String name) { + this.name = name; + } + + public long id() { + return id; + } + + public ESoftWithCache id(long id) { + this.id = id; + return this; + } + + public String name() { + return name; + } + + public ESoftWithCache name(String name) { + this.name = name; + return this; + } + + public String description() { + return description; + } + + public ESoftWithCache description(String description) { + this.description = description; + return this; + } + + public long version() { + return version; + } + + public ESoftWithCache version(long version) { + this.version = version; + return this; + } +} diff --git a/ebean-core/src/test/java/org/tests/model/basic/cache/TestCacheWithSoftDelete.java b/ebean-core/src/test/java/org/tests/model/basic/cache/TestCacheWithSoftDelete.java new file mode 100644 index 000000000..a4d8d5b7c --- /dev/null +++ b/ebean-core/src/test/java/org/tests/model/basic/cache/TestCacheWithSoftDelete.java @@ -0,0 +1,34 @@ +package org.tests.model.basic.cache; + +import io.ebean.BaseTestCase; +import io.ebean.DB; +import org.junit.Test; + +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThat; + +public class TestCacheWithSoftDelete extends BaseTestCase { + + @Test + public void idIn_expect_hitCache() { + + ESoftWithCache bean = new ESoftWithCache("hello"); + DB.save(bean); + + final List found = DB.find(ESoftWithCache.class) + .where().idIn(bean.id()) + //.setUseCache(true) + .findList(); + + assertThat(found).hasSize(1); + + final List foundAgain = DB.find(ESoftWithCache.class) + .where().idIn(bean.id()) + //.setUseCache(true) + .findList(); + + assertThat(foundAgain).hasSize(1); + + } +} From 6fe6b8ba646af5d0c3b3b901da2e0a0c71e538b9 Mon Sep 17 00:00:00 2001 From: rbygrave Date: Thu, 2 Sep 2021 17:10:56 +1200 Subject: [PATCH 2/3] #2335 - L2 cache be triggered by in ? --- .../io/ebeaninternal/api/LoadBeanRequest.java | 47 ++++++++---------- .../io/ebeaninternal/api/LoadManyRequest.java | 32 ++++--------- .../io/ebeaninternal/api/LoadRequest.java | 3 -- .../server/core/DefaultBeanLoader.java | 4 -- .../server/query/DefaultOrmQueryEngine.java | 2 +- .../server/querydefn/DefaultOrmQuery.java | 6 +-- .../tests/basic/TestReadOnlyPropagation.java | 16 +++---- .../batchload/TestBatchLazyWithCacheHits.java | 48 +++++++------------ .../org/tests/batchload/TestQueryJoin.java | 5 +- .../tests/batchload/TestSecondaryQueries.java | 7 +-- .../tests/cache/TestBeanFetchJoinCache.java | 24 ++++------ .../basic/cache/TestCacheWithSoftDelete.java | 20 ++++++-- .../rawsql/nativesql/TestNativeSqlBasic.java | 8 +--- 13 files changed, 88 insertions(+), 134 deletions(-) diff --git a/ebean-core/src/main/java/io/ebeaninternal/api/LoadBeanRequest.java b/ebean-core/src/main/java/io/ebeaninternal/api/LoadBeanRequest.java index a763182b2..a60dfc3f1 100644 --- a/ebean-core/src/main/java/io/ebeaninternal/api/LoadBeanRequest.java +++ b/ebean-core/src/main/java/io/ebeaninternal/api/LoadBeanRequest.java @@ -1,7 +1,9 @@ package io.ebeaninternal.api; +import io.ebean.CacheMode; import io.ebean.bean.EntityBean; import io.ebean.bean.EntityBeanIntercept; +import io.ebeaninternal.api.SpiQuery.Mode; import io.ebeaninternal.server.core.OrmQueryRequest; import io.ebeaninternal.server.deploy.BeanDescriptor; @@ -19,30 +21,29 @@ public final class LoadBeanRequest extends LoadRequest { private final LoadBeanBuffer loadBuffer; private final String lazyLoadProperty; private final boolean loadCache; - private boolean loadedFromCache; + private final boolean alreadyLoaded; /** * Construct for lazy load request. */ - public LoadBeanRequest(LoadBeanBuffer LoadBuffer, EntityBeanIntercept ebi, boolean loadCache) { - this(LoadBuffer, null, true, ebi.getLazyLoadProperty(), loadCache); - this.loadedFromCache = ebi.isLoadedFromCache(); + public LoadBeanRequest(LoadBeanBuffer loadBuffer, EntityBeanIntercept ebi, boolean loadCache) { + this(loadBuffer, null, true, ebi.getLazyLoadProperty(), ebi.isLoaded(), loadCache || ebi.isLoadedFromCache()); } /** * Construct for secondary query. */ - public LoadBeanRequest(LoadBeanBuffer LoadBuffer, OrmQueryRequest parentRequest) { - this(LoadBuffer, parentRequest, false, null, false); + public LoadBeanRequest(LoadBeanBuffer loadBuffer, OrmQueryRequest parentRequest) { + this(loadBuffer, parentRequest, false, null, false, false); } private LoadBeanRequest(LoadBeanBuffer loadBuffer, OrmQueryRequest parentRequest, boolean lazy, - String lazyLoadProperty, boolean loadCache) { - + String lazyLoadProperty, boolean alreadyLoaded, boolean loadCache) { super(parentRequest, lazy); this.loadBuffer = loadBuffer; this.batch = loadBuffer.getBatch(); this.lazyLoadProperty = lazyLoadProperty; + this.alreadyLoaded = alreadyLoaded; this.loadCache = loadCache; } @@ -51,17 +52,6 @@ public final class LoadBeanRequest extends LoadRequest { return loadBuffer.getBeanDescriptor().getBeanType(); } - /** - * Return true if the beans invoking lazy loading were previously loaded from cache. - */ - public boolean isLoadedFromCache() { - return loadedFromCache; - } - - private boolean isLoadCache() { - return loadCache; - } - public String getDescription() { return "path:" + loadBuffer.getFullPath() + " batch:" + batch.size(); } @@ -100,16 +90,21 @@ public final class LoadBeanRequest extends LoadRequest { * Configure the query for lazy loading execution. */ public void configureQuery(SpiQuery query, List idList) { - query.setMode(SpiQuery.Mode.LAZYLOAD_BEAN); + query.setMode(Mode.LAZYLOAD_BEAN); query.setPersistenceContext(loadBuffer.getPersistenceContext()); - String mode = isLazy() ? "+lazy" : "+query"; - query.setLoadDescription(mode, getDescription()); - - if (isLazy()) { - // cascade the batch size (if set) for further lazy loading + query.setLoadDescription(lazy ? "+lazy" : "+query", getDescription()); + if (lazy) { query.setLazyLoadBatchSize(getBatchSize()); + if (alreadyLoaded) { + query.setBeanCacheMode(CacheMode.OFF); + } + } else { + query.setBeanCacheMode(CacheMode.OFF); } loadBuffer.configureQuery(query, lazyLoadProperty); + if (loadCache) { + query.setBeanCacheMode(CacheMode.PUT); + } if (idList.size() == 1) { query.where().idEq(idList.get(0)); } else { @@ -128,7 +123,7 @@ public final class LoadBeanRequest extends LoadRequest { EntityBean loadedBean = (EntityBean) bean; loadedIds.add(desc.getId(loadedBean)); } - if (isLoadCache()) { + if (loadCache) { desc.cacheBeanPutAll(list); } if (lazyLoadProperty != null) { diff --git a/ebean-core/src/main/java/io/ebeaninternal/api/LoadManyRequest.java b/ebean-core/src/main/java/io/ebeaninternal/api/LoadManyRequest.java index cd49558d6..8975af534 100644 --- a/ebean-core/src/main/java/io/ebeaninternal/api/LoadManyRequest.java +++ b/ebean-core/src/main/java/io/ebeaninternal/api/LoadManyRequest.java @@ -1,5 +1,6 @@ package io.ebeaninternal.api; +import io.ebean.CacheMode; import io.ebean.bean.BeanCollection; import io.ebean.bean.EntityBean; import io.ebeaninternal.server.core.BindPadding; @@ -62,17 +63,6 @@ public final class LoadManyRequest extends LoadRequest { return batch; } - /** - * Return true if lazy loading should only load the id values. - *

- * This for use when lazy loading is invoked on methods such as clear() and removeAll() where it - * generally makes sense to only fetch the Id values as the other property information is not - * used. - */ - private boolean isOnlyIds() { - return onlyIds; - } - /** * Return true if we should load the Collection ids into the cache. */ @@ -111,31 +101,25 @@ public final class LoadManyRequest extends LoadRequest { if (orderBy != null) { query.order(orderBy); } - String extraWhere = many.getExtraWhere(); if (extraWhere != null) { // replace special ${ta} placeholder with the base table alias // which is always t0 and add the extra where clause query.where().raw(extraWhere.replace("${ta}", "t0").replace("${mta}", "int_")); } - query.setLazyLoadForParents(many); many.addWhereParentIdIn(query, parentIdList(server), loadContext.isUseDocStore()); query.setPersistenceContext(loadContext.getPersistenceContext()); - - String mode = isLazy() ? "+lazy" : "+query"; - query.setLoadDescription(mode, getDescription()); - - if (isLazy()) { - // cascade the batch size (if set) for further lazy loading + query.setLoadDescription(lazy ? "+lazy" : "+query", getDescription()); + if (lazy) { query.setLazyLoadBatchSize(getBatchSize()); + } else { + query.setBeanCacheMode(CacheMode.OFF); } - - // potentially changes the joins and selected properties + // potentially changes the joins, selected properties, cache mode loadContext.configureQuery(query); - - if (isOnlyIds()) { - // override to just select the Id values + if (onlyIds) { + // lazy loading invoked via clear() and removeAll() query.select(many.getTargetIdProperty()); } return query; diff --git a/ebean-core/src/main/java/io/ebeaninternal/api/LoadRequest.java b/ebean-core/src/main/java/io/ebeaninternal/api/LoadRequest.java index 516bcddb2..3c797ced5 100644 --- a/ebean-core/src/main/java/io/ebeaninternal/api/LoadRequest.java +++ b/ebean-core/src/main/java/io/ebeaninternal/api/LoadRequest.java @@ -9,13 +9,10 @@ import io.ebeaninternal.server.core.OrmQueryRequest; public abstract class LoadRequest { protected final OrmQueryRequest parentRequest; - protected final Transaction transaction; - protected final boolean lazy; public LoadRequest(OrmQueryRequest parentRequest, boolean lazy) { - this.parentRequest = parentRequest; this.transaction = parentRequest == null ? null : parentRequest.getTransaction(); this.lazy = lazy; diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/core/DefaultBeanLoader.java b/ebean-core/src/main/java/io/ebeaninternal/server/core/DefaultBeanLoader.java index adc91e5b4..108e7e95f 100644 --- a/ebean-core/src/main/java/io/ebeaninternal/server/core/DefaultBeanLoader.java +++ b/ebean-core/src/main/java/io/ebeaninternal/server/core/DefaultBeanLoader.java @@ -147,10 +147,6 @@ final class DefaultBeanLoader { SpiQuery query = server.createQuery(loadRequest.getBeanType()); loadRequest.configureQuery(query, idList); - if (loadRequest.isLoadedFromCache()) { - query.setBeanCacheMode(CacheMode.PUT); - } - List list = executeQuery(loadRequest, query); loadRequest.postLoad(list); } diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/query/DefaultOrmQueryEngine.java b/ebean-core/src/main/java/io/ebeaninternal/server/query/DefaultOrmQueryEngine.java index abab7cdf9..84ea2d737 100644 --- a/ebean-core/src/main/java/io/ebeaninternal/server/query/DefaultOrmQueryEngine.java +++ b/ebean-core/src/main/java/io/ebeaninternal/server/query/DefaultOrmQueryEngine.java @@ -133,7 +133,7 @@ public final class DefaultOrmQueryEngine implements OrmQueryEngine { SpiQuery query = request.getQuery(); - if (request.isBeanCachePutMany()) { + if (result != null && request.isBeanCachePutMany()) { // load the individual beans into the bean cache BeanDescriptor descriptor = request.getBeanDescriptor(); Collection c = result.getActualDetails(); diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/querydefn/DefaultOrmQuery.java b/ebean-core/src/main/java/io/ebeaninternal/server/querydefn/DefaultOrmQuery.java index 65ba6b9a3..39952d042 100644 --- a/ebean-core/src/main/java/io/ebeaninternal/server/querydefn/DefaultOrmQuery.java +++ b/ebean-core/src/main/java/io/ebeaninternal/server/querydefn/DefaultOrmQuery.java @@ -1232,10 +1232,8 @@ public final class DefaultOrmQuery extends AbstractQuery implements SpiQuery< @Override public void resetBeanCacheAutoMode(boolean findOne) { - if (useBeanCache == CacheMode.AUTO) { - if (!findOne || useQueryCache != CacheMode.OFF) { - useBeanCache = CacheMode.OFF; - } + if (useBeanCache == CacheMode.AUTO && useQueryCache != CacheMode.OFF) { + useBeanCache = CacheMode.OFF; } } diff --git a/ebean-core/src/test/java/org/tests/basic/TestReadOnlyPropagation.java b/ebean-core/src/test/java/org/tests/basic/TestReadOnlyPropagation.java index 4417e5451..4325c5332 100644 --- a/ebean-core/src/test/java/org/tests/basic/TestReadOnlyPropagation.java +++ b/ebean-core/src/test/java/org/tests/basic/TestReadOnlyPropagation.java @@ -1,8 +1,7 @@ package org.tests.basic; import io.ebean.BaseTestCase; -import io.ebean.CacheMode; -import io.ebean.Ebean; +import io.ebean.DB; import io.ebean.bean.BeanCollection; import org.junit.Assert; import org.junit.Test; @@ -16,6 +15,8 @@ import java.util.Iterator; import java.util.List; import java.util.ListIterator; +import static org.junit.Assert.assertNotNull; + public class TestReadOnlyPropagation extends BaseTestCase { @Test @@ -23,21 +24,20 @@ public class TestReadOnlyPropagation extends BaseTestCase { ResetBasicData.reset(); - Order order = Ebean.find(Order.class) - .setAutoTune(false) - .setBeanCacheMode(CacheMode.OFF) + Order order = DB.find(Order.class) .setReadOnly(true) .setId(1) .findOne(); - Assert.assertTrue(Ebean.getBeanState(order).isReadOnly()); + Assert.assertTrue(DB.getBeanState(order).isReadOnly()); Customer customer = order.getCustomer(); - Assert.assertTrue(Ebean.getBeanState(customer).isReadOnly()); + Assert.assertTrue(DB.getBeanState(customer).isReadOnly()); Address billingAddress = customer.getBillingAddress(); - Assert.assertTrue(Ebean.getBeanState(billingAddress).isReadOnly()); + assertNotNull(billingAddress); + //Assert.assertTrue(Ebean.getBeanState(billingAddress).isReadOnly()); List details = order.getDetails(); diff --git a/ebean-core/src/test/java/org/tests/batchload/TestBatchLazyWithCacheHits.java b/ebean-core/src/test/java/org/tests/batchload/TestBatchLazyWithCacheHits.java index d6066f66e..2869b2121 100644 --- a/ebean-core/src/test/java/org/tests/batchload/TestBatchLazyWithCacheHits.java +++ b/ebean-core/src/test/java/org/tests/batchload/TestBatchLazyWithCacheHits.java @@ -1,7 +1,7 @@ package org.tests.batchload; import io.ebean.BaseTestCase; -import io.ebean.Ebean; +import io.ebean.DB; import io.ebean.cache.ServerCache; import io.ebean.cache.ServerCacheStatistics; import org.tests.model.basic.UUOne; @@ -17,66 +17,53 @@ import static org.junit.Assert.assertNotNull; public class TestBatchLazyWithCacheHits extends BaseTestCase { - private ServerCache beanCache = server().getServerCacheManager().getBeanCache(UUOne.class); + private final ServerCache beanCache = server().getServerCacheManager().getBeanCache(UUOne.class); private UUOne insert(String name) { UUOne one = new UUOne(); one.setName("testBLWCH" + name); - Ebean.save(one); + DB.save(one); return one; } @Test public void testOnCacheHit() { - - ArrayList inserted = insertData(); - + List inserted = insertData(); clearCacheAndStatistics(); - UUOne b = Ebean.find(UUOne.class, inserted.get(1).getId()); - assertNotNull(b); - - UUOne b2 = Ebean.find(UUOne.class, inserted.get(1).getId()); - assertNotNull(b2); - + assertNotNull(DB.find(UUOne.class, inserted.get(1).getId())); + // cache hit + assertNotNull(DB.find(UUOne.class, inserted.get(1).getId())); assertBeanCacheHits(1); - UUOne c = Ebean.find(UUOne.class) - .where().idEq(inserted.get(2).getId()) - .findOne(); - assertNotNull(c); - - UUOne c2 = Ebean.find(UUOne.class) - .where().idEq(inserted.get(2).getId()) - .findOne(); - - assertNotNull(c2); + assertNotNull(DB.find(UUOne.class).where().idEq(inserted.get(2).getId()).findOne()); + // cache hit + assertNotNull(DB.find(UUOne.class).where().idEq(inserted.get(2).getId()).findOne()); assertBeanCacheHits(1); LoggedSqlCollector.start(); - List list = Ebean.find(UUOne.class) - //.setDefaultLazyLoadBatchSize(5) + List list = DB.find(UUOne.class) .select("id") .where().startsWith("name", "testBLWCH") .order("name") .findList(); + // invoke lazy loading for (UUOne uuOne : list) { uuOne.getName(); } list.get(0).getName(); List sql = LoggedSqlCollector.stop(); - System.out.println("sql:" + sql); - assertThat(sql).hasSize(2); assertSql(sql.get(0)).contains("from uuone t0 where t0.name like "); platformAssertIn(sql.get(1), "from uuone t0 where t0.id"); // not lazy loading into bean cache - int size = beanCache.getStatistics(true).getSize(); - assertThat(size).isEqualTo(2); + final ServerCacheStatistics stats = beanCache.getStatistics(true); + assertThat(stats.getHitCount()).isEqualTo(10); + assertThat(stats.getSize()).isEqualTo(10); } private void assertBeanCacheHits(int hits) { @@ -85,13 +72,12 @@ public class TestBatchLazyWithCacheHits extends BaseTestCase { } private void clearCacheAndStatistics() { - beanCache.clear(); beanCache.getStatistics(true); } - private ArrayList insertData() { - ArrayList inserted = new ArrayList<>(); + private List insertData() { + List inserted = new ArrayList<>(); String[] names = "A,B,C,D,E,F,G,H,I,J".split(","); for (String name : names) { inserted.add(insert(name)); diff --git a/ebean-core/src/test/java/org/tests/batchload/TestQueryJoin.java b/ebean-core/src/test/java/org/tests/batchload/TestQueryJoin.java index 533dd5470..71b5a4b4d 100644 --- a/ebean-core/src/test/java/org/tests/batchload/TestQueryJoin.java +++ b/ebean-core/src/test/java/org/tests/batchload/TestQueryJoin.java @@ -27,9 +27,8 @@ public class TestQueryJoin extends BaseTestCase { custCache.clear(); Query query = Ebean.find(Order.class).select("status") - // .join("details","+query(10)") - .fetchLazy("customer", "name, status").fetch("customer.contacts").order().asc("id"); - // .join("customer.billingAddress"); + .fetchLazy("customer", "name, status") + .fetch("customer.contacts").order().asc("id"); List list = query.findList(); diff --git a/ebean-core/src/test/java/org/tests/batchload/TestSecondaryQueries.java b/ebean-core/src/test/java/org/tests/batchload/TestSecondaryQueries.java index b61b1fbac..e2895c493 100644 --- a/ebean-core/src/test/java/org/tests/batchload/TestSecondaryQueries.java +++ b/ebean-core/src/test/java/org/tests/batchload/TestSecondaryQueries.java @@ -1,10 +1,6 @@ package org.tests.batchload; -import io.ebean.Ebean; -import io.ebean.FetchConfig; -import io.ebean.Query; -import io.ebean.QueryIterator; -import io.ebean.TransactionalTestCase; +import io.ebean.*; import org.ebeantest.LoggedSqlCollector; import org.junit.Test; import org.tests.model.basic.Customer; @@ -42,6 +38,7 @@ public class TestSecondaryQueries extends TransactionalTestCase { public void fetchLazy() { LoggedSqlCollector.start(); + DB.getServerCacheManager().clearAll(); List orders = Ebean.find(Order.class) .select("status") diff --git a/ebean-core/src/test/java/org/tests/cache/TestBeanFetchJoinCache.java b/ebean-core/src/test/java/org/tests/cache/TestBeanFetchJoinCache.java index f036dded5..d22c21e3b 100644 --- a/ebean-core/src/test/java/org/tests/cache/TestBeanFetchJoinCache.java +++ b/ebean-core/src/test/java/org/tests/cache/TestBeanFetchJoinCache.java @@ -22,10 +22,8 @@ public class TestBeanFetchJoinCache extends BaseTestCase { @Test public void fetchCache_when_allHits() { - initDataClearCache(); loadCustomerBeanCache(); - customerBeanCache.getStatistics(true); LoggedSqlCollector.start(); @@ -59,7 +57,6 @@ public class TestBeanFetchJoinCache extends BaseTestCase { @Test public void fetchCache_when_someHits() { - initDataClearCache(); DB.find(Customer.class) @@ -94,7 +91,6 @@ public class TestBeanFetchJoinCache extends BaseTestCase { @Test public void fetchCache_when_hitsButBeanCachePartiallyLoaded() { - initDataClearCache(); DB.find(Customer.class) @@ -110,6 +106,9 @@ public class TestBeanFetchJoinCache extends BaseTestCase { .fetchCache("customer") .findList(); + for (Order order : orders) { + assertThat(order.getCustomer().getName()).isNotNull(); + } final List sql0 = LoggedSqlCollector.current(); assertThat(sql0).hasSize(1); @@ -121,17 +120,17 @@ public class TestBeanFetchJoinCache extends BaseTestCase { for (Order order : orders) { final Customer customer = order.getCustomer(); assertThat(customer.getName()).isNotNull(); - assertThat(customer.getStatus()).isNotNull(); // We hit the DB here as previously hit bean cache + assertThat(customer.getStatus()).isNotNull(); // We cache miss on property(status) } - // assert we didn't hit the L2 bean cache the second time around - final ServerCacheStatistics statistics1 = customerBeanCache.getStatistics(true); - assertThat(statistics1.getHitCount()).isEqualTo(0); - - // assert we did hit the DB the second time around + // assert we hit the DB the second time around final List sql1 = LoggedSqlCollector.stop(); assertThat(sql1).hasSize(1); assertThat(sql1.get(0)).contains(" from o_customer t0 "); + + // assert we didn't hit the L2 bean cache the second time around + final ServerCacheStatistics statistics1 = customerBeanCache.getStatistics(true); + assertThat(statistics1.getHitCount()).isGreaterThan(0); } private final FetchGroup fgBasic = FetchGroup.of(Order.class) @@ -140,9 +139,7 @@ public class TestBeanFetchJoinCache extends BaseTestCase { @Test public void fetchGroup_fetchCache() { - initDataClearCache(); - loadCustomerBeanCache(); customerBeanCache.getStatistics(true); @@ -160,12 +157,9 @@ public class TestBeanFetchJoinCache extends BaseTestCase { .fetchCache("customer", "name") .build(); - @Test public void fetchGroup_fetchCache_partial() { - initDataClearCache(); - customerBeanCache.getStatistics(true); LoggedSqlCollector.start(); diff --git a/ebean-core/src/test/java/org/tests/model/basic/cache/TestCacheWithSoftDelete.java b/ebean-core/src/test/java/org/tests/model/basic/cache/TestCacheWithSoftDelete.java index a4d8d5b7c..321c50dc1 100644 --- a/ebean-core/src/test/java/org/tests/model/basic/cache/TestCacheWithSoftDelete.java +++ b/ebean-core/src/test/java/org/tests/model/basic/cache/TestCacheWithSoftDelete.java @@ -2,6 +2,9 @@ package org.tests.model.basic.cache; import io.ebean.BaseTestCase; import io.ebean.DB; +import io.ebean.cache.ServerCache; +import io.ebean.cache.ServerCacheStatistics; +import io.ebeantest.LoggedSql; import org.junit.Test; import java.util.List; @@ -10,25 +13,34 @@ import static org.assertj.core.api.Assertions.assertThat; public class TestCacheWithSoftDelete extends BaseTestCase { + private final ServerCache beanCache = DB.getServerCacheManager().getBeanCache(ESoftWithCache.class); + @Test public void idIn_expect_hitCache() { - ESoftWithCache bean = new ESoftWithCache("hello"); DB.save(bean); final List found = DB.find(ESoftWithCache.class) .where().idIn(bean.id()) - //.setUseCache(true) .findList(); - assertThat(found).hasSize(1); + // try to hit the cache + assertThat(stats().getPutCount()).isEqualTo(1); + + LoggedSql.start(); + // cache hit success this time final List foundAgain = DB.find(ESoftWithCache.class) .where().idIn(bean.id()) - //.setUseCache(true) .findList(); + final List sql = LoggedSql.stop(); + assertThat(sql).isEmpty(); assertThat(foundAgain).hasSize(1); + assertThat(stats().getHitCount()).isEqualTo(1); + } + private ServerCacheStatistics stats() { + return beanCache.getStatistics(true); } } diff --git a/ebean-core/src/test/java/org/tests/rawsql/nativesql/TestNativeSqlBasic.java b/ebean-core/src/test/java/org/tests/rawsql/nativesql/TestNativeSqlBasic.java index 4e0ccfd02..b127b249a 100644 --- a/ebean-core/src/test/java/org/tests/rawsql/nativesql/TestNativeSqlBasic.java +++ b/ebean-core/src/test/java/org/tests/rawsql/nativesql/TestNativeSqlBasic.java @@ -1,9 +1,6 @@ package org.tests.rawsql.nativesql; -import io.ebean.BaseTestCase; -import io.ebean.BeanState; -import io.ebean.Ebean; -import io.ebean.Query; +import io.ebean.*; import io.ebean.annotation.IgnorePlatform; import io.ebean.annotation.Platform; import org.ebeantest.LoggedSqlCollector; @@ -157,11 +154,10 @@ public class TestNativeSqlBasic extends BaseTestCase { @Test public void partialAssocIncludingOracle() { - ResetBasicData.reset(); + DB.getServerCacheManager().clearAll(); String nativeSql = "select o.id, o.status, o.kcustomer_id from o_order o"; - List orders = Ebean.findNative(Order.class, nativeSql) .findList(); From e0afeea6c48dde36005f01a98c713f4402df88c8 Mon Sep 17 00:00:00 2001 From: rbygrave Date: Thu, 2 Sep 2021 19:03:54 +1200 Subject: [PATCH 3/3] #2335 - Modify test - Put back readOnly assert (#2340) --- .../src/test/java/org/tests/basic/TestReadOnlyPropagation.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ebean-core/src/test/java/org/tests/basic/TestReadOnlyPropagation.java b/ebean-core/src/test/java/org/tests/basic/TestReadOnlyPropagation.java index 4325c5332..58a1ae64e 100644 --- a/ebean-core/src/test/java/org/tests/basic/TestReadOnlyPropagation.java +++ b/ebean-core/src/test/java/org/tests/basic/TestReadOnlyPropagation.java @@ -37,7 +37,7 @@ public class TestReadOnlyPropagation extends BaseTestCase { Address billingAddress = customer.getBillingAddress(); assertNotNull(billingAddress); - //Assert.assertTrue(Ebean.getBeanState(billingAddress).isReadOnly()); + Assert.assertTrue(DB.getBeanState(billingAddress).isReadOnly()); List details = order.getDetails();