#405 - ENH: Add @ReadAudit and associated functionality for auditing reads including queries and L2 cache access

src/test/java/com/avaje/ebeaninternal/api/TDSpiEbeanServer.java

@@ -9,6 +9,8 @@ import com.avaje.ebean.cache.ServerCacheManager;
 import com.avaje.ebean.config.ServerConfig;
 import com.avaje.ebean.config.dbplatform.DatabasePlatform;
 import com.avaje.ebean.dbmigration.DdlGenerator;
+import com.avaje.ebean.event.readaudit.ReadAuditLogger;
+import com.avaje.ebean.event.readaudit.ReadAuditPrepare;
 import com.avaje.ebean.meta.MetaInfoManager;
 import com.avaje.ebean.plugin.SpiServer;
 import com.avaje.ebean.text.csv.CsvReader;
@@ -91,6 +93,16 @@ public class TDSpiEbeanServer implements SpiEbeanServer {
     return null;
   }
 
+  @Override
+  public ReadAuditLogger getReadAuditLogger() {
+    return null;
+  }
+
+  @Override
+  public ReadAuditPrepare getReadAuditPrepare() {
+    return null;
+  }
+
   @Override
   public void clearQueryStatistics() {
 

src/test/java/com/avaje/ebeaninternal/server/core/TestDiffHelpInsertSimple.java

@@ -51,7 +51,7 @@ public class TestDiffHelpInsertSimple extends BaseTestCase {
 
     Order order1 = createBaseOrder(server);
 
-    Map<String, ValuePair> diff = DiffHelpInsert.diff((EntityBean) order1, orderDesc);
+    Map<String, ValuePair> diff = orderDesc.diffForInsert((EntityBean) order1);
 
     assertEquals(4, diff.size());
 

src/test/java/com/avaje/ebeaninternal/server/core/TestDiffHelpInsertWithEmbedded.java

@@ -34,7 +34,7 @@ public class TestDiffHelpInsertWithEmbedded extends BaseTestCase {
 
     EMain emain1 = createEMain();
 
-    Map<String, ValuePair> diff = DiffHelpInsert.diff((EntityBean) emain1, emainDesc);
+    Map<String, ValuePair> diff = emainDesc.diffForInsert((EntityBean) emain1);
     assertEquals(3, diff.size());
     assertEquals("foo", diff.get("name").getNewValue());
     assertEquals(13L, diff.get("version").getNewValue());
@@ -51,7 +51,7 @@ public class TestDiffHelpInsertWithEmbedded extends BaseTestCase {
     EMain emain1 = createEMain();
     emain1.setName(null);
 
-    Map<String, ValuePair> diff = DiffHelpInsert.diff((EntityBean) emain1, emainDesc);
+    Map<String, ValuePair> diff = emainDesc.diffForInsert((EntityBean) emain1);
     assertEquals(2, diff.size());
     assertNull(diff.get("name"));
     assertEquals(13L, diff.get("version").getNewValue());
@@ -68,7 +68,7 @@ public class TestDiffHelpInsertWithEmbedded extends BaseTestCase {
     EMain emain1 = createEMain();
     emain1.setEmbeddable(null);
 
-    Map<String, ValuePair> diff = DiffHelpInsert.diff((EntityBean) emain1, emainDesc);
+    Map<String, ValuePair> diff = emainDesc.diffForInsert((EntityBean) emain1);
     assertEquals(2, diff.size());
     assertEquals("foo", diff.get("name").getNewValue());
     assertEquals(13L, diff.get("version").getNewValue());
@@ -83,7 +83,7 @@ public class TestDiffHelpInsertWithEmbedded extends BaseTestCase {
     EMain emain1 = createEMain();
     emain1.getEmbeddable().setDescription(null);
 
-    Map<String, ValuePair> diff = DiffHelpInsert.diff((EntityBean) emain1, emainDesc);
+    Map<String, ValuePair> diff = emainDesc.diffForInsert((EntityBean) emain1);
     assertEquals(2, diff.size());
     assertEquals("foo", diff.get("name").getNewValue());
     assertEquals(13L, diff.get("version").getNewValue());

src/test/java/com/avaje/ebeaninternal/server/core/TestDiffHelpWithEmbedded.java

@@ -66,7 +66,25 @@ public class TestDiffHelpWithEmbedded extends BaseTestCase {
     Assert.assertEquals("bar",valuePair.getNewValue());
     Assert.assertEquals("baz",valuePair.getOldValue());
   }
-  
+
+  @Test
+  public void testDiffEmbedded_flatMode() {
+
+    EMain emain1 = createEMain();
+    EMain emain2 = createEMain();
+    emain2.getEmbeddable().setDescription("baz");
+
+    DiffHelp diffHelp = new DiffHelp(true);
+
+    Map<String, ValuePair> diff = diffHelp.diff(emain1, emain2, emainDesc);
+    Assert.assertEquals(1, diff.size());
+    ValuePair valuePair = diff.get("embeddable.description");
+
+    Assert.assertNotNull(valuePair);
+    Assert.assertEquals("bar",valuePair.getNewValue());
+    Assert.assertEquals("baz",valuePair.getOldValue());
+  }
+
   @Test
   public void testFirstEmbeddedIsNull() {
     

src/test/java/com/avaje/ebeaninternal/server/deploy/TestBeanDescriptorHasIdProperty.java

@@ -1,10 +1,5 @@
 package com.avaje.ebeaninternal.server.deploy;
 
-import java.sql.Timestamp;
-
-import org.junit.Assert;
-import org.junit.Test;
-
 import com.avaje.ebean.BaseTestCase;
 import com.avaje.ebean.Ebean;
 import com.avaje.ebean.EbeanServer;
@@ -13,6 +8,17 @@ import com.avaje.ebean.bean.EntityBeanIntercept;
 import com.avaje.ebeaninternal.api.SpiEbeanServer;
 import com.avaje.tests.model.basic.Customer;
 import com.avaje.tests.model.basic.Order;
+import com.avaje.tests.model.composite.RCustomer;
+import com.avaje.tests.model.composite.RCustomerKey;
+import org.junit.Test;
+
+import java.sql.Timestamp;
+import java.util.Map;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
 
 public class TestBeanDescriptorHasIdProperty extends BaseTestCase {
 
@@ -27,22 +33,22 @@ public class TestBeanDescriptorHasIdProperty extends BaseTestCase {
   public void testHasId() {
   
     BeanDescriptor<Order> beanDescriptor = spiServer.getBeanDescriptor(Order.class);
-    Assert.assertNotNull(beanDescriptor.getIdProperty());
-    Assert.assertEquals("id", beanDescriptor.getIdProperty().getName());
+    assertNotNull(beanDescriptor.getIdProperty());
+    assertEquals("id", beanDescriptor.getIdProperty().getName());
     
-    Assert.assertNotNull(beanDescriptor.getVersionProperty());
-    Assert.assertEquals("updtime", beanDescriptor.getVersionProperty().getName());
+    assertNotNull(beanDescriptor.getVersionProperty());
+    assertEquals("updtime", beanDescriptor.getVersionProperty().getName());
     
     Order order = new Order();
     
-    Assert.assertFalse(beanDescriptor.hasIdValue(entityBean(order)));
-    Assert.assertFalse(beanDescriptor.hasVersionProperty(getIntercept(order)));
+    assertFalse(beanDescriptor.hasIdValue(entityBean(order)));
+    assertFalse(beanDescriptor.hasVersionProperty(getIntercept(order)));
     
     order.setId(23);
     order.setUpdtime(new Timestamp(System.currentTimeMillis()));
 
-    Assert.assertTrue(beanDescriptor.hasIdValue(entityBean(order)));
-    Assert.assertTrue(beanDescriptor.hasVersionProperty(getIntercept(order)));
+    assertTrue(beanDescriptor.hasIdValue(entityBean(order)));
+    assertTrue(beanDescriptor.hasVersionProperty(getIntercept(order)));
     
   }
 
@@ -53,13 +59,47 @@ public class TestBeanDescriptorHasIdProperty extends BaseTestCase {
     
     Customer order = new Customer();
     EntityBeanIntercept ebi = getIntercept(order);
-    Assert.assertFalse(beanDescriptor.hasIdPropertyOnly(ebi));
+    assertFalse(beanDescriptor.hasIdPropertyOnly(ebi));
     
     order.setId(23);
-    Assert.assertTrue(beanDescriptor.hasIdPropertyOnly(ebi));
+    assertTrue(beanDescriptor.hasIdPropertyOnly(ebi));
 
     order.setName("custName");
-    Assert.assertFalse(beanDescriptor.hasIdPropertyOnly(ebi));
+    assertFalse(beanDescriptor.hasIdPropertyOnly(ebi));
+  }
+
+  @Test
+  public void test_getIdForJson() {
+
+    BeanDescriptor<Order> orderDesc = spiServer.getBeanDescriptor(Order.class);
+
+    Order order = new Order();
+    order.setId(42);
+    assertEquals(42, orderDesc.getIdForJson(order));
+
+    assertEquals(42, orderDesc.convertIdFromJson(42));
+    assertEquals(42, orderDesc.convertIdFromJson("42"));
+    assertEquals(42, orderDesc.convertIdFromJson(42L));
+
+
+    RCustomerKey key = new RCustomerKey();
+    key.setCompany("comp");
+    key.setName("fred");
+
+    RCustomer rCustomer = new RCustomer();
+    rCustomer.setKey(key);
+
+    BeanDescriptor<RCustomer> rcustDesc = spiServer.getBeanDescriptor(RCustomer.class);
+
+    Map<String,Object> idForJson = (Map<String,Object>)rcustDesc.getIdForJson(rCustomer);
+    assertEquals("comp",idForJson.get("company"));
+    assertEquals("fred",idForJson.get("name"));
+    assertEquals(2, idForJson.size());
+
+    RCustomerKey keyVal = (RCustomerKey)rcustDesc.convertIdFromJson(idForJson);
+    assertEquals("comp",keyVal.getCompany());
+    assertEquals("fred",keyVal.getName());
+
   }
 
   private EntityBean entityBean(Object bean) {

src/test/java/com/avaje/tests/model/basic/Country.java

@@ -4,6 +4,7 @@ import com.avaje.ebean.annotation.CacheStrategy;
 import com.avaje.ebean.annotation.CacheTuning;
 import com.avaje.ebean.annotation.ChangeLog;
 import com.avaje.ebean.annotation.ChangeLogInsertMode;
+import com.avaje.ebean.annotation.ReadAudit;
 
 import javax.persistence.Entity;
 import javax.persistence.Id;
@@ -13,6 +14,7 @@ import javax.validation.constraints.Size;
 /**
  * Country entity bean.
  */
+@ReadAudit
 @ChangeLog(inserts = ChangeLogInsertMode.INCLUDE)
 @CacheStrategy(readOnly = true, warmingQuery = "order by name")
 @CacheTuning(maxSize = 500)

src/test/java/com/avaje/tests/model/basic/EBasicChangeLog.java

@@ -1,6 +1,7 @@
 package com.avaje.tests.model.basic;
 
 import com.avaje.ebean.annotation.ChangeLog;
+import com.avaje.ebean.annotation.ReadAudit;
 import com.avaje.ebean.annotation.WhenCreated;
 import com.avaje.ebean.annotation.WhenModified;
 import com.avaje.ebean.annotation.WhoCreated;
@@ -12,9 +13,7 @@ import javax.persistence.Version;
 import javax.validation.constraints.Size;
 import java.sql.Timestamp;
 
-/**
- *
- */
+@ReadAudit
 @ChangeLog(updatesThatInclude = {"name","shortDescription"})
 @Entity
 public class EBasicChangeLog {

src/test/java/com/avaje/tests/query/TestIContains.java

@@ -1,6 +1,8 @@
 package com.avaje.tests.query;
 
 
+import com.avaje.ebean.RawSql;
+import com.avaje.ebean.RawSqlBuilder;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -33,6 +35,14 @@ public class TestIContains extends BaseTestCase {
 
     Assert.assertTrue(generatedSql.contains(" t0.name "));
 
+    Ebean.find(Customer.class).where().icontains("name", "Rob").findList();
+    Ebean.find(Customer.class).where().icontains("name", "Rob").findList();
+    Ebean.find(Customer.class).where().icontains("name", "Rob").findList();
+
+    String sql = "select id, status, name from o_customer where lower(name) like :name";
+    RawSql parse = RawSqlBuilder.parse(sql).create();
+
+    Ebean.find(Customer.class).setRawSql(parse).setParameter("name", "Jim").findList();
   }
 
 }

src/test/java/com/avaje/tests/readaudit/TestReadAudit.java

@@ -0,0 +1,381 @@
+package com.avaje.tests.readaudit;
+
+import com.avaje.ebean.BaseTestCase;
+import com.avaje.ebean.EbeanServerFactory;
+import com.avaje.ebean.FutureList;
+import com.avaje.ebean.QueryEachConsumer;
+import com.avaje.ebean.cache.ServerCache;
+import com.avaje.ebean.cache.ServerCacheStatistics;
+import com.avaje.ebean.config.ServerConfig;
+import com.avaje.ebean.event.readaudit.ReadAuditLogger;
+import com.avaje.ebean.event.readaudit.ReadAuditPrepare;
+import com.avaje.ebean.event.readaudit.ReadAuditQueryPlan;
+import com.avaje.ebean.event.readaudit.ReadEvent;
+import com.avaje.ebeaninternal.api.SpiEbeanServer;
+import com.avaje.tests.model.basic.Country;
+import com.avaje.tests.model.basic.EBasicChangeLog;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TestReadAudit extends BaseTestCase {
+
+  TDReadAuditPrepare readAuditPrepare = new TDReadAuditPrepare(true);
+
+  TDReadAuditLogger readAuditLogger = new TDReadAuditLogger(true);
+
+  SpiEbeanServer server;
+
+  Long id1;
+  Long id2;
+
+  @Before
+  public void setup() {
+    server = getServer();
+
+    EBasicChangeLog bean = new EBasicChangeLog();
+    bean.setName("readAudito1");
+    bean.setShortDescription("readAudit hello");
+    server.save(bean);
+    id1 = bean.getId();
+
+    EBasicChangeLog bean2 = new EBasicChangeLog();
+    bean2.setName("readAudito2");
+    bean2.setShortDescription("readAudit hi");
+    server.save(bean2);
+    id2 = bean2.getId();
+
+    Country ar = new Country();
+    ar.setCode("AR");
+    ar.setName("Argentina");
+    server.save(ar);
+  }
+
+  @After
+  public void shutdown() {
+    server.shutdown(true, false);
+  }
+
+  @Test
+  public void test_findById() {
+    resetCounters();
+
+    EBasicChangeLog found = server.find(EBasicChangeLog.class, id1);
+    assertThat(found).isNotNull();
+    assertThat(readAuditPrepare.count).isEqualTo(1);
+    assertThat(readAuditLogger.plans).hasSize(1);
+    assertThat(readAuditLogger.beans).hasSize(1);
+    assertThat(readAuditLogger.beans.get(0).getBeanType()).isEqualTo(EBasicChangeLog.class.getName());
+    assertThat(readAuditLogger.beans.get(0).getId()).isEqualTo(id1);
+  }
+
+  @Test
+  public void test_findById_usingL2Cache() {
+    resetCounters();
+
+    EBasicChangeLog found = server.find(EBasicChangeLog.class).setId(id1).setUseCache(true).findUnique();
+    assertThat(found).isNotNull();
+    assertThat(readAuditPrepare.count).isEqualTo(1);
+    assertThat(readAuditLogger.plans).hasSize(1);
+    assertThat(readAuditLogger.beans).hasSize(1);
+    assertThat(readAuditLogger.beans.get(0).getBeanType()).isEqualTo(EBasicChangeLog.class.getName());
+    assertThat(readAuditLogger.beans.get(0).getId()).isEqualTo(id1);
+
+    ServerCache beanCache = server.getServerCacheManager().getBeanCache(EBasicChangeLog.class);
+    ServerCacheStatistics statistics = beanCache.getStatistics(false);
+    assertThat(statistics.getSize()).isEqualTo(1);
+    assertThat(statistics.getHitCount()).isEqualTo(0);
+
+    EBasicChangeLog found2 = server.find(EBasicChangeLog.class).setId(id1).setUseCache(true).findUnique();
+    assertThat(found2).isNotNull();
+    statistics = beanCache.getStatistics(false);
+    assertThat(statistics.getSize()).isEqualTo(1);
+    assertThat(statistics.getHitCount()).isEqualTo(1);
+
+    assertThat(readAuditLogger.beans).hasSize(2);
+  }
+
+  @Test
+  public void test_findById_usingL2Cache_sharedBean() {
+    resetCounters();
+
+    Country found = server.find(Country.class).setId("AR").setUseCache(true).findUnique();
+    assertThat(found).isNotNull();
+    assertThat(readAuditPrepare.count).isEqualTo(1);
+    assertThat(readAuditLogger.plans).hasSize(1);
+    assertThat(readAuditLogger.beans).hasSize(1);
+    assertThat(readAuditLogger.beans.get(0).getBeanType()).isEqualTo(Country.class.getName());
+    assertThat(readAuditLogger.beans.get(0).getId()).isEqualTo("AR");
+
+    ServerCache beanCache = server.getServerCacheManager().getBeanCache(Country.class);
+    ServerCacheStatistics statistics = beanCache.getStatistics(false);
+    assertThat(statistics.getSize()).isEqualTo(1);
+    assertThat(statistics.getHitCount()).isEqualTo(0);
+
+    Country found2 = server.find(Country.class).setId("AR").setUseCache(true).findUnique();
+    assertThat(found2).isNotNull();
+    statistics = beanCache.getStatistics(false);
+    assertThat(statistics.getSize()).isEqualTo(1);
+    assertThat(statistics.getHitCount()).isEqualTo(1);
+
+    assertThat(readAuditLogger.beans).hasSize(2);
+
+    Country ref = server.getReference(Country.class, "AR");
+    assertThat(readAuditLogger.beans).hasSize(3);
+    assertThat(ref).isSameAs(found2);
+  }
+
+  @Test
+  public void test_findList() {
+
+    resetCounters();
+
+    List<EBasicChangeLog> list = server.find(EBasicChangeLog.class)
+        .where().startsWith("shortDescription", "readAudit")
+        .findList();
+
+    assertThat(list).hasSize(2);
+    assertThat(readAuditPrepare.count).isEqualTo(1);
+    assertThat(readAuditLogger.plans).hasSize(1);
+    assertThat(readAuditLogger.many).hasSize(1);
+    assertThat(readAuditLogger.many.get(0).getBeanType()).isEqualTo(EBasicChangeLog.class.getName());
+    assertThat(readAuditLogger.many.get(0).getIds()).contains(id1, id2);
+
+    server.find(EBasicChangeLog.class)
+        .where().startsWith("shortDescription", "readAudit")
+        .findList();
+
+    assertThat(readAuditPrepare.count).isEqualTo(2);
+    assertThat(readAuditLogger.plans).hasSize(1);
+    assertThat(readAuditLogger.many).hasSize(2);
+  }
+
+  @Test
+  public void test_findList_useL2Cache() {
+
+    resetCounters();
+
+    List<EBasicChangeLog> list = server.find(EBasicChangeLog.class)
+        .setUseQueryCache(true)
+        .where().startsWith("shortDescription", "readAudit")
+        .findList();
+
+    assertThat(list).hasSize(2);
+    assertThat(readAuditPrepare.count).isEqualTo(1);
+    assertThat(readAuditLogger.plans).hasSize(1);
+    assertThat(readAuditLogger.many).hasSize(1);
+    assertThat(readAuditLogger.many.get(0).getBeanType()).isEqualTo(EBasicChangeLog.class.getName());
+    assertThat(readAuditLogger.many.get(0).getIds()).contains(id1, id2);
+
+    ServerCache queryCache = server.getServerCacheManager().getQueryCache(EBasicChangeLog.class);
+    ServerCacheStatistics statistics = queryCache.getStatistics(false);
+    assertThat(statistics.getSize()).isEqualTo(1);
+    assertThat(statistics.getHitCount()).isEqualTo(0);
+
+    server.find(EBasicChangeLog.class)
+        .setUseQueryCache(true)
+        .where().startsWith("shortDescription", "readAudit")
+        .findList();
+
+    statistics = queryCache.getStatistics(false);
+    assertThat(statistics.getSize()).isEqualTo(1);
+    assertThat(statistics.getHitCount()).isEqualTo(1);
+
+    assertThat(readAuditPrepare.count).isEqualTo(2);
+    assertThat(readAuditLogger.plans).hasSize(1);
+    assertThat(readAuditLogger.many).hasSize(2);
+  }
+
+  @Test
+  public void test_findFutureList() throws ExecutionException, InterruptedException {
+
+    resetCounters();
+
+    FutureList<EBasicChangeLog> futureList = server.find(EBasicChangeLog.class)
+        .where().startsWith("shortDescription", "readAudit")
+        .findFutureList();
+
+    List<EBasicChangeLog> list = futureList.get();
+    assertThat(list).hasSize(2);
+    assertThat(readAuditPrepare.count).isEqualTo(1);
+    assertThat(readAuditLogger.plans).hasSize(1);
+    assertThat(readAuditLogger.many).hasSize(1);
+    assertThat(readAuditLogger.many.get(0).getBeanType()).isEqualTo(EBasicChangeLog.class.getName());
+    assertThat(readAuditLogger.many.get(0).getIds()).contains(id1, id2);
+
+    server.find(EBasicChangeLog.class)
+        .where().startsWith("shortDescription", "readAudit")
+        .findList();
+
+    assertThat(readAuditPrepare.count).isEqualTo(2);
+    assertThat(readAuditLogger.plans).hasSize(1);
+    assertThat(readAuditLogger.many).hasSize(2);
+  }
+
+  @Test
+  public void test_findSet() {
+
+    resetCounters();
+
+    Set<EBasicChangeLog> list = server.find(EBasicChangeLog.class)
+        .where().startsWith("shortDescription", "readAudit")
+        .findSet();
+
+    assertThat(list).hasSize(2);
+    assertThat(readAuditPrepare.count).isEqualTo(1);
+    assertThat(readAuditLogger.plans).hasSize(1);
+    assertThat(readAuditLogger.many).hasSize(1);
+    assertThat(readAuditLogger.many.get(0).getIds()).contains(id1, id2);
+
+    server.find(EBasicChangeLog.class)
+        .where().startsWith("shortDescription", "readAudit")
+        .findSet();
+
+    assertThat(readAuditPrepare.count).isEqualTo(2);
+    assertThat(readAuditLogger.plans).hasSize(1);
+    assertThat(readAuditLogger.many).hasSize(2);
+  }
+
+  @Test
+  public void test_findMap() {
+
+    resetCounters();
+
+    Map<?,EBasicChangeLog> list = server.find(EBasicChangeLog.class)
+        .where().startsWith("shortDescription", "readAudit")
+        .findMap();
+
+    assertThat(list).hasSize(2);
+    assertThat(readAuditPrepare.count).isEqualTo(1);
+    assertThat(readAuditLogger.plans).hasSize(1);
+    assertThat(readAuditLogger.many).hasSize(1);
+    assertThat(readAuditLogger.many.get(0).getIds()).contains(id1, id2);
+
+    server.find(EBasicChangeLog.class)
+        .where().startsWith("shortDescription", "readAudit")
+        .findMap();
+
+    assertThat(readAuditPrepare.count).isEqualTo(2);
+    assertThat(readAuditLogger.plans).hasSize(1);
+    assertThat(readAuditLogger.many).hasSize(2);
+  }
+
+  @Test
+  public void test_findEach() {
+
+    resetCounters();
+
+    final AtomicInteger count = new AtomicInteger();
+    server.find(EBasicChangeLog.class)
+        .where().startsWith("shortDescription", "readAudit")
+        .findEach(new QueryEachConsumer<EBasicChangeLog>() {
+          @Override
+          public void accept(EBasicChangeLog bean) {
+            count.incrementAndGet();
+          }
+        });
+
+    assertThat(count.get()).isEqualTo(2);
+    assertThat(readAuditPrepare.count).isEqualTo(1);
+    assertThat(readAuditLogger.plans).hasSize(1);
+    assertThat(readAuditLogger.many).hasSize(1);
+    assertThat(readAuditLogger.many.get(0).getIds()).contains(id1, id2);
+
+    server.find(EBasicChangeLog.class)
+        .where().startsWith("shortDescription", "readAudit")
+        .findEach(new QueryEachConsumer<EBasicChangeLog>() {
+          @Override
+          public void accept(EBasicChangeLog bean) {
+            count.incrementAndGet();
+          }
+        });
+
+    assertThat(readAuditPrepare.count).isEqualTo(2);
+    assertThat(readAuditLogger.plans).hasSize(1);
+    assertThat(readAuditLogger.many).hasSize(2);
+  }
+
+  private SpiEbeanServer getServer() {
+
+    ServerConfig config = new ServerConfig();
+    config.setName("h2other");
+    config.loadFromProperties();
+
+    config.setDdlGenerate(true);
+    config.setDdlRun(true);
+    config.setDefaultServer(false);
+    config.setRegister(false);
+
+    config.addClass(Country.class);
+    config.addClass(EBasicChangeLog.class);
+
+    config.setReadAuditLogger(readAuditLogger);
+    config.setReadAuditPrepare(readAuditPrepare);
+
+    return (SpiEbeanServer) EbeanServerFactory.create(config);
+  }
+
+  private void resetCounters() {
+    readAuditLogger.resetCounters();
+    readAuditPrepare.resetCounters();
+  }
+
+  class TDReadAuditPrepare implements ReadAuditPrepare {
+
+    int count;
+
+    TDReadAuditPrepare(boolean dummy) {
+    }
+    void resetCounters() {
+      count = 0;
+    }
+
+    @Override
+    public void prepare(ReadEvent event) {
+      count++;
+      event.setUserId("appUser1");
+      event.setUserIpAddress("1.1.1.1");
+      event.getUserContext().put("some", "thing");
+    }
+  }
+
+  class TDReadAuditLogger implements ReadAuditLogger {
+
+    List<ReadAuditQueryPlan> plans = new ArrayList<ReadAuditQueryPlan>();
+    List<ReadEvent> beans = new ArrayList<ReadEvent>();
+    List<ReadEvent> many = new ArrayList<ReadEvent>();
+
+    TDReadAuditLogger(boolean dummy) {
+    }
+    void resetCounters() {
+      plans.clear();
+      beans.clear();
+      many.clear();
+    }
+
+    @Override
+    public void queryPlan(ReadAuditQueryPlan queryPlan) {
+      plans.add(queryPlan);
+    }
+
+    @Override
+    public void auditBean(ReadEvent readBean) {
+      beans.add(readBean);
+    }
+
+    @Override
+    public void auditMany(ReadEvent readMany) {
+      many.add(readMany);
+    }
+  }
+
+}