Ensured virtual lists can use batches to load child objects, added tests

Author: tim-aero

README.md

@@ -1617,18 +1617,15 @@ When mapping a Java object to Aerospike the most common operations to do are to
 - Validate some of the limits, eg bin name length, set name length, etc.
 - Make all maps (esp Embedded ones) K_ORDERED
 - Add interface to adaptiveMap, including changing EmbedType
-- Make lists of references load the data via batch loads.
 - Document all parameters to annotations and examples of types
 - Document enums, dates, instants.
-- Test to ensure List<AerospikeRecord> / Map<AerospikeRecord> cannot have both an embed and reference annotations / multiple annotations.
 - Document configuration file. 
 - Document creation of builder -- multiple configuration files are allowed, if the same class is declared in both the first one encountered wins. 
 - Document methods with 2 parameters for keys and setters, the second one either a Key or a Value
 - Document subclasses and the mapping to tables + references stored as lists
 - Batch load of child items on Maps and References. Ensure testing of non-parameterized classes too. Also of methods on Virtual LIsts
-- Test (and fix) batch loading of children on virtual lists.
 - Document batch loading
-- Ensure batchloading option exists in AerospikeReference Configuration
+- Ensure batch loading option exists in AerospikeReference Configuration
 - handle object graph circularities (A->B->C). Be careful of: A->B(Lazy), A->C->B: B should end up fully hydrated in both instances, not lazy in both instances
 - Consider the items on virtual list which return a list to be able to return a map as well (ELEMENT_LIST, ELEMENT_MAP) 
 - Test if map supports lazy loading of referenced objects.

src/main/java/com/aerospike/mapper/tools/AeroMapper.java

@@ -184,7 +184,7 @@ private <T> ClassCacheEntry<T> getEntryAndValidateNamespace(Class<T> clazz) {
 	        namespace = entry.getNamespace();
         }
         if (StringUtils.isBlank(namespace)) {
-            throw new AerospikeException("Namespace not specified to save a record of type " + clazz.getName());
+            throw new AerospikeException("Namespace not specified to perform database operation on a record of type " + clazz.getName());
         }
         return entry;
     }
@@ -563,7 +563,7 @@ public <T> Map<String, Object> convertToMap(@NotNull T instance) {
      * the list of deferred objects is empty. The deferred objects are stored in a <pre>ThreadLocalData<pre> list, so are thread safe
      * @param parentEntity - the ClassCacheEntry of the parent entity. This is used to get the batch policy to use.
      */
-    private void resolveDependencies(ClassCacheEntry<?> parentEntity) {
+    void resolveDependencies(ClassCacheEntry<?> parentEntity) {
     	List<DeferredObjectSetter> deferredObjects = DeferredObjectLoader.getAndClear();
 
     	if (deferredObjects.size() == 0) {
@@ -583,7 +583,7 @@ private void resolveDependencies(ClassCacheEntry<?> parentEntity) {
     			DeferredObjectSetter thisObjectSetter = deferredObjects.get(i);
     			DeferredObject deferredObject = thisObjectSetter.getObject();
     			Class<?> clazz = deferredObject.getType();
-    			ClassCacheEntry<?> entry = (ClassCacheEntry<?>) ClassCache.getInstance().loadClass(clazz, this);
+    			ClassCacheEntry<?> entry = getEntryAndValidateNamespace(clazz);
     			classCaches[i] = entry; 
 
     			if (deferredObject.isDigest()) {

src/main/java/com/aerospike/mapper/tools/VirtualList.java

@@ -1,6 +1,7 @@
 package com.aerospike.mapper.tools;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
@@ -178,6 +179,14 @@ else if (this.indexToReturn >= 0) {
 		 * @return
 		 */
 		public Object end() {
+			return end(null);
+		}
+		
+		/**
+		 * Finish the multi operation and process it. 
+		 * @return
+		 */
+		public <T> T end(Class<T> resultType) {
 			if (this.interactions.isEmpty()) {
 				return null;
 			}
@@ -202,9 +211,10 @@ public Object end() {
 
     		Record record = this.virtualList.mapper.mClient.operate(writePolicy, key, operations);
 
+    		T result;
     		if (count == 1) {
     			Object resultObj = record.getValue(binName);
-    			return this.interactions.get(0).getResult(resultObj);
+    			result = (T)this.interactions.get(0).getResult(resultObj);
     		}
 			else {
 				List<?> resultList = record.getList(binName);
@@ -218,8 +228,17 @@ public Object end() {
 						}
 					}
 				}
-				return this.interactions.get(indexToReturn).getResult(resultList.get(indexToReturn));
+				result = (T)this.interactions.get(indexToReturn).getResult(resultList.get(indexToReturn));
 			}
+    		if (result != null) {
+    			Object object = result;
+    			if (result instanceof Collection) {
+    				Collection<T> collection = (Collection<T>)result;
+    				object = collection.isEmpty() ? null : collection.iterator().next();
+    			}
+    			mapper.resolveDependencies(ClassCache.getInstance().loadClass(object.getClass(), mapper));
+    		}
+			return result;
 		}
 	}
 

src/test/java/com/aerospike/mapper/CompetingAnnotationsTest.java

@@ -0,0 +1,130 @@
+package com.aerospike.mapper;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.util.List;
+import java.util.Map;
+
+import org.junit.Test;
+
+import com.aerospike.client.AerospikeException;
+import com.aerospike.mapper.annotations.AerospikeEmbed;
+import com.aerospike.mapper.annotations.AerospikeKey;
+import com.aerospike.mapper.annotations.AerospikeRecord;
+import com.aerospike.mapper.annotations.AerospikeReference;
+import com.aerospike.mapper.tools.AeroMapper;
+
+public class CompetingAnnotationsTest extends AeroMapperBaseTest {
+
+	@AerospikeRecord(namespace = "test", set = "A")
+	public static class A {
+		@AerospikeKey
+		int a;
+		String b;
+	}
+	
+	@AerospikeRecord(namespace = "test", set = "B")
+	public static class CompetingReferenceAndEmbedAnnotations {
+		@AerospikeKey
+		int key;
+		@AerospikeEmbed
+		@AerospikeReference
+		A a;
+	}
+	
+	@AerospikeRecord(namespace = "test", set = "B")
+	public static class CompetingListReferenceAndEmbedAnnotations {
+		@AerospikeKey
+		int key;
+		@AerospikeEmbed
+		@AerospikeReference
+		List<A> a;
+	}
+	
+	@AerospikeRecord(namespace = "test", set = "B")
+	public static class CompetingMapReferenceAndEmbedAnnotations {
+		@AerospikeKey
+		int key;
+		@AerospikeEmbed
+		@AerospikeReference
+		Map<Integer, A> a;
+	}
+	
+	@AerospikeRecord(namespace = "test", set = "B")
+	public static class CompetingArrayReferenceAndEmbedAnnotations {
+		@AerospikeKey
+		int key;
+		@AerospikeEmbed
+		@AerospikeReference
+		A[] a;
+	}
+	
+	@Test
+	public void testCompetingReferenceAndEmbedAnnotations() {
+		AeroMapper mapper = new AeroMapper.Builder(client).build();
+
+		A a = new A();
+		a.a = 2;
+		a.b = "hello";
+		
+		CompetingReferenceAndEmbedAnnotations b = new CompetingReferenceAndEmbedAnnotations();
+		b.key = 1;
+		b.a = a;
+		
+		try {
+			mapper.save(b);
+			fail();
+		}
+		catch (AerospikeException ae) {
+			assertTrue(true);
+		}
+	}
+
+	@Test
+	public void testCompetingListReferenceAndEmbedAnnotations() {
+		AeroMapper mapper = new AeroMapper.Builder(client).build();
+		
+		CompetingListReferenceAndEmbedAnnotations b = new CompetingListReferenceAndEmbedAnnotations();
+		b.key = 1;
+		
+		try {
+			mapper.save(b);
+			fail();
+		}
+		catch (AerospikeException ae) {
+			assertTrue(true);
+		}
+	}
+
+	@Test
+	public void testMapCompetingReferenceAndEmbedAnnotations() {
+		AeroMapper mapper = new AeroMapper.Builder(client).build();
+
+		CompetingMapReferenceAndEmbedAnnotations b = new CompetingMapReferenceAndEmbedAnnotations();
+		b.key = 1;
+		try {
+			mapper.save(b);
+			fail();
+		}
+		catch (AerospikeException ae) {
+			assertTrue(true);
+		}
+	}
+
+	@Test
+	public void testCompetingArrayReferenceAndEmbedAnnotations() {
+		AeroMapper mapper = new AeroMapper.Builder(client).build();
+		
+		CompetingArrayReferenceAndEmbedAnnotations b = new CompetingArrayReferenceAndEmbedAnnotations();
+		b.key = 1;
+		
+		try {
+			mapper.save(b);
+			fail();
+		}
+		catch (AerospikeException ae) {
+			assertTrue(true);
+		}
+	}
+}