BaseAggregatedTest.java

package siena.base.test;

import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

import junit.framework.TestCase;
import siena.Model;
import siena.PersistenceManager;
import siena.PersistenceManagerFactory;
import siena.base.test.model.AggregateChildManualModel;
import siena.base.test.model.AggregateChildModel;
import siena.base.test.model.AggregateParentManualModel;
import siena.base.test.model.AggregateParentModel;

public abstract class BaseAggregatedTest extends TestCase {
	
	protected PersistenceManager pm;

	public abstract PersistenceManager createPersistenceManager(List<Class<?>> classes) throws Exception;
	

	@Override
	protected void setUp() throws Exception {
		super.setUp();
		List<Class<?>> classes = new ArrayList<Class<?>>();
		classes.add(AggregateChildModel.class);
		classes.add(AggregateParentModel.class);
		
		pm = createPersistenceManager(classes);
		PersistenceManagerFactory.install(pm, classes);
			
		for (Class<?> clazz : classes) {
			if(!Modifier.isAbstract(clazz.getModifiers())){
				pm.createQuery(clazz).delete();			
			}
		}

	}
	
	public void testAggregateMostSimple() {
		AggregateParentModel god = new AggregateParentModel("god");
		god.insert();
		assertNotNull(god.id);
		
		AggregateChildModel adam1 = new AggregateChildModel("adam1");
		adam1.aggregate(god, "child");
		adam1.insert();
		
		assertNotNull(adam1.id);
		assertNotNull(adam1.getRelation());

		AggregateParentModel god1 = 
			Model.getByKey(AggregateParentModel.class, god.id);
		assertNotNull(god1);
		assertEquals(adam1, god1.child.get());
		
		adam1.name = "adam1_UPD";
		adam1.update();
		
		assertEquals(adam1, god1.child.forceSync().get());
		
		adam1.name = "adam1_UPD2";
		adam1.save();
		
		assertEquals(adam1, god1.child.forceSync().get());
		
		AggregateChildModel adam2 = new AggregateChildModel("adam2");
		adam2.aggregate(god, "child");
		adam2.save();
		
		assertEquals(adam1, god1.child.forceSync().get());
		
		god1.child.set(adam2);
		god1.update();

		AggregateParentModel god2 = 
			Model.getByKey(AggregateParentModel.class, god1.id);
		assertNotNull(god2);
		assertEquals(adam2, god2.child.get());
		
		AggregateChildModel adam3 = new AggregateChildModel("adam3");
		adam3.aggregate(god, "child");
		adam3.save();
		
		god.child.set(adam3);
		god.update();
		
		AggregateParentModel god3 = 
			Model.getByKey(AggregateParentModel.class, god.id);
		assertNotNull(god3);
		assertEquals(adam2, god3.child.get());
		
		god.child.forceSync().set(adam3);
		god.update();
		
		god3 = 
			Model.getByKey(AggregateParentModel.class, god.id);
		assertNotNull(god3);
		assertEquals(adam3, god3.child.get());
		
		adam3.delete();
		assertNull(god3.child.forceSync().get());
	}

	public void testAggregateMostSimpleMultiple() {
		AggregateParentModel god = new AggregateParentModel("god");
		god.insert();
		assertNotNull(god.id);

		AggregateChildModel adam1 = new AggregateChildModel("adam1");
		adam1.aggregate(god, "child");
		adam1.insert();
		
		AggregateChildModel adam2 = new AggregateChildModel("adam2");	
		adam2.aggregate(god, "children");
		adam2.insert();

		AggregateChildModel eve = new AggregateChildModel("eve");
		eve.aggregate(god, "children");
		eve.insert();

		AggregateChildModel bob = new AggregateChildModel("bob");
		bob.aggregate(god, "children");
		bob.insert();

		AggregateParentModel god1 = 
			Model.getByKey(AggregateParentModel.class, god.id);
		
		assertNotNull(god1);
		assertEquals(adam1, god1.child.get());
		List<AggregateChildModel> children = god1.children.asQuery().fetch();
		assertEquals(adam2, children.get(0));
		assertEquals(eve, children.get(1));
		assertEquals(bob, children.get(2));
		
		eve.delete();
		children = god1.children.asList().forceSync();
		assertEquals(adam2, children.get(0));
		assertEquals(bob, children.get(1));
	}
	
	public void testAggregate() {
		AggregateChildModel adam1 = new AggregateChildModel("adam1");
		AggregateChildModel adam2 = new AggregateChildModel("adam2");	
		AggregateChildModel eve = new AggregateChildModel("eve");
		AggregateChildModel bob = new AggregateChildModel("bob");

		AggregateParentModel god = new AggregateParentModel("god");
		god.child.set(adam1);
		god.children.asList().addAll(adam2, eve, bob);				
		god.insert();
		
		assertNotNull(god.id);
		assertNotNull(god.child.get().id);
		
		AggregateParentModel god1 = 
			Model.getByKey(AggregateParentModel.class, god.id);
		
		assertNotNull(god1);
		assertEquals(adam1, god1.child.get());
		List<AggregateChildModel> children = god1.children.asQuery().fetch();
		assertEquals(adam2, children.get(0));
		assertEquals(eve, children.get(1));
		assertEquals(bob, children.get(2));
		
		// get aggregated one2one
		AggregateChildModel adamAfter2 = AggregateChildModel.all().aggregated(god, "child").get();
		assertEquals(adam1, adamAfter2);
		
		// get aggregated one2many
		children = AggregateChildModel.all().aggregated(god, "children").fetch();
		assertEquals(adam2, children.get(0));
		assertEquals(eve, children.get(1));
		assertEquals(bob, children.get(2));

		AggregateParentModel god2 = AggregateParentModel.all().filter("name", "god").get();
		assertEquals(adam1, god2.child.get());
		children = god2.children.asList();
		assertEquals(adam2, children.get(0));
		assertEquals(eve, children.get(1));
		assertEquals(bob, children.get(2));
	}
	
	public void testAggregateUpdate() {
		AggregateChildModel adam1 = new AggregateChildModel("adam1");
		AggregateChildModel adam2 = new AggregateChildModel("adam2");	
		AggregateChildModel eve = new AggregateChildModel("eve");
		AggregateChildModel bob = new AggregateChildModel("bob");

		AggregateParentModel god = new AggregateParentModel("god");
		god.child.set(adam1);
		god.children.asList().addAll(Arrays.asList(adam2, eve, bob));
				
		god.insert();
		
		assertNotNull(god.id);
		assertNotNull(god.child.get().id);
		
		god.name = "goddy";
		adam1.name = "adammy";
		adam1.save();
		bob.name = "bobby";
		bob.save();
		eve.name = "evvy";
		eve.save();
		
		god.update();
		
		AggregateParentModel godbis = AggregateParentModel.all().filter("name", "goddy").get();
		assertEquals(god, godbis);
		List<AggregateChildModel> children = godbis.children.asList();
		assertEquals(adam2, children.get(0));
		assertEquals(eve, children.get(1));
		assertEquals(bob, children.get(2));
		
		god.children.asList().remove(eve);
		god.update();
		
		godbis = AggregateParentModel.all().filter("name", "goddy").get();
		assertEquals(god, godbis);
		children = godbis.children.asList();
		assertEquals(adam2, children.get(0));
		assertEquals(bob, children.get(1));
	}
	
	public void testAggregateSave() {
		AggregateChildModel adam1 = new AggregateChildModel("adam1");
		AggregateChildModel adam2 = new AggregateChildModel("adam2");	
		AggregateChildModel eve = new AggregateChildModel("eve");
		AggregateChildModel bob = new AggregateChildModel("bob");

		AggregateParentModel god = new AggregateParentModel("god");
		god.child.set(adam1);
		god.children.asList().addAll(Arrays.asList(adam2, eve, bob));
				
		god.save();
		
		assertNotNull(god.id);
		assertNotNull(god.child.get().id);
		
		AggregateParentModel god1 = 
			Model.getByKey(AggregateParentModel.class, god.id);
		
		assertNotNull(god1);
		assertEquals(adam1, god1.child.get());
		List<AggregateChildModel> children = god1.children.asQuery().fetch();
		assertEquals(adam2, children.get(0));
		assertEquals(eve, children.get(1));
		assertEquals(bob, children.get(2));

		god.name = "goddy";
		adam1.name = "adammy";
		bob.name = "bobby";
		eve.name = "evvy";
		
		Model.batch(AggregateChildModel.class).update(adam1, bob, eve);
		
		god.save();
		
		AggregateParentModel godbis = AggregateParentModel.all().filter("name", "goddy").get();
		assertNotNull(godbis);
		assertEquals(god.id, godbis.id);
		assertEquals(god.name, godbis.name);
		children = godbis.children.asList();
		assertEquals(adam2, children.get(0));
		assertEquals(eve, children.get(1));
		assertEquals(bob, children.get(2));
		
		god.children.asList().remove(eve);
		god.save();
		
		godbis = AggregateParentModel.all().filter("name", "goddy").get();
		assertEquals(god, godbis);
		children = godbis.children.asList();
		assertEquals(adam2, children.get(0));
		assertEquals(bob, children.get(1));
	}
	
	public void testAggregateDelete() {
		AggregateChildModel adam1 = new AggregateChildModel("adam1");
		AggregateChildModel adam2 = new AggregateChildModel("adam2");	
		AggregateChildModel eve = new AggregateChildModel("eve");
		AggregateChildModel bob = new AggregateChildModel("bob");

		AggregateParentModel god = new AggregateParentModel("god");
		god.child.set(adam1);
		god.children.asList().addAll(Arrays.asList(adam2, eve, bob));
				
		god.insert();
		
		assertNotNull(god.id);
		assertNotNull(god.child.get().id);
		
		god.delete();
		
		AggregateParentModel godbis = AggregateParentModel.all().filter("name", "god").get();
		assertNull(godbis);
		
		List<AggregateChildModel> children = Model.batch(AggregateChildModel.class).getByKeys(adam1.id, adam2.id, eve.id, bob.id);
		assertEquals(4, children.size());
		assertEquals(null, children.get(0));
		assertEquals(null, children.get(1));
		assertEquals(null, children.get(2));
		assertEquals(null, children.get(3));
	}
	
	public void testAggregateDeleteChildOfChildren() {
		AggregateChildModel adam1 = new AggregateChildModel("adam1");
		AggregateChildModel adam2 = new AggregateChildModel("adam2");	
		AggregateChildModel eve = new AggregateChildModel("eve");
		AggregateChildModel bob = new AggregateChildModel("bob");

		AggregateParentModel god = new AggregateParentModel("god");
		god.child.set(adam1);
		god.children.asList().addAll(Arrays.asList(adam2, eve, bob));
				
		god.insert();
		
		assertNotNull(god.id);
		assertNotNull(god.child.get().id);
		
		god.children.asList().remove(eve);
		god.update();
		
		AggregateParentModel godbis = AggregateParentModel.all().filter("name", "god").get();
		assertEquals(god, godbis);
		List<AggregateChildModel> children = godbis.children.asList();
		assertEquals(adam2, children.get(0));
		assertEquals(bob, children.get(1));
	}
	
	public void testAggregateAddChild() {
		AggregateChildModel adam1 = new AggregateChildModel("adam1");
		AggregateChildModel adam2 = new AggregateChildModel("adam2");	
		AggregateChildModel eve = new AggregateChildModel("eve");
		AggregateChildModel bob = new AggregateChildModel("bob");
		AggregateChildModel eve2 = new AggregateChildModel("eve2");

		AggregateParentModel god = new AggregateParentModel("god");
		god.child.set(adam1);
		god.children.asList().addAll(Arrays.asList(adam2, eve, bob));
				
		god.insert();
		
		assertNotNull(god.id);
		assertNotNull(god.child.get().id);
		
		god.children.asList().add(eve2);
		god.update();
		
		AggregateParentModel godbis = AggregateParentModel.all().filter("name", "god").get();
		assertEquals(god, godbis);
		List<AggregateChildModel> children = godbis.children.asList();
		assertEquals(adam2, children.get(0));
		assertEquals(eve, children.get(1));
		assertEquals(bob, children.get(2));
		assertEquals(eve2, children.get(3));
	}
	
	public void testAggregateListQuerysFetch() {
		List<AggregateChildModel> adams = new ArrayList<AggregateChildModel>();
		for(int i=0; i<100; i++){
			AggregateChildModel adam = new AggregateChildModel();
			adam.name = "adam"+i;
			adams.add(adam);
		}
		
		AggregateChildModel eve = new AggregateChildModel("eve");

		AggregateParentModel god = new AggregateParentModel("god");
		god.child.set(eve);
		god.children.asList().addAll(adams);
				
		god.insert();
		
		assertNotNull(god.id);
		assertNotNull(god.child.get().id);
		
		// get aggregated one2many
		AggregateParentModel godbis = AggregateParentModel.all().filter("name", "god").get();
		List<AggregateChildModel> children = godbis.children.asQuery().fetch();
		for(int i=0; i<100; i++){
			assertEquals(adams.get(i), children.get(i));			
		}
		
		for(int i=0; i<100; i++){
			assertEquals(adams.get(i), godbis.children.asList().get(i));			
		}
		
		Iterator<AggregateChildModel> it = godbis.children.asList().iterator();
		int i=0;
		while(it.hasNext()){
			assertEquals(adams.get(i++), it.next());	
		}
		assertEquals(100, i);
	}
	
	public void testAggregateListQuerysFetchLimit() {
		List<AggregateChildModel> adams = new ArrayList<AggregateChildModel>();
		for(int i=0; i<100; i++){
			AggregateChildModel adam = new AggregateChildModel();
			adam.name = "adam"+i;
			adams.add(adam);
		}
		
		AggregateChildModel eve = new AggregateChildModel();
		eve.name = "eve";

		AggregateParentModel god = new AggregateParentModel();
		god.name = "god";
		god.child.set(eve);
		god.children.asList().addAll(adams);
				
		god.insert();
		
		assertNotNull(god.id);
		assertNotNull(god.child.get().id);
		
		// get aggregated one2many
		AggregateParentModel godbis = AggregateParentModel.all().filter("name", "god").get();
		List<AggregateChildModel> children_0_10 = godbis.children.asQuery().fetch(10);
		for(int i=0; i<10; i++){
			assertEquals(adams.get(i), children_0_10.get(i));			
		}
		
		for(int i=0; i<100; i++){
			assertEquals(adams.get(i), godbis.children.asList().get(i));			
		}
		
		Iterator<AggregateChildModel> it = godbis.children.asList().iterator();
		int i=0;
		while(it.hasNext()){
			assertEquals(adams.get(i++), it.next());	
		}
		assertEquals(100, i);
	}
	
	public void testAggregateListQuerysFetchLimitOffset() {
		List<AggregateChildModel> adams = new ArrayList<AggregateChildModel>();
		for(int i=0; i<100; i++){
			AggregateChildModel adam = new AggregateChildModel();
			adam.name = "adam"+i;
			adams.add(adam);
		}
		
		AggregateChildModel eve = new AggregateChildModel();
		eve.name = "eve";

		AggregateParentModel god = new AggregateParentModel();
		god.name = "god";
		god.child.set(eve);
		god.children.asList().addAll(adams);
				
		god.insert();
		
		assertNotNull(god.id);
		assertNotNull(god.child.get().id);
		
		// get aggregated one2many
		AggregateParentModel godbis = AggregateParentModel.all().filter("name", "god").get();
		List<AggregateChildModel> children_26_36 = godbis.children.asQuery().fetch(10, 26);
		for(int i=0; i<10; i++){
			assertEquals(adams.get(i+26), children_26_36.get(i));			
		}
		
		for(int i=0; i<100; i++){
			assertEquals(adams.get(i), godbis.children.asList().get(i));			
		}
		
		Iterator<AggregateChildModel> it = godbis.children.asList().iterator();
		int i=0;
		while(it.hasNext()){
			assertEquals(adams.get(i++), it.next());	
		}
		assertEquals(100, i);
	}
	
	public void testAggregateListQuerysFetchKeys() {
		List<AggregateChildModel> adams = new ArrayList<AggregateChildModel>();
		for(int i=0; i<100; i++){
			AggregateChildModel adam = new AggregateChildModel();
			adam.name = "adam"+i;
			adams.add(adam);
		}
		
		AggregateChildModel eve = new AggregateChildModel();
		eve.name = "eve";

		AggregateParentModel god = new AggregateParentModel();
		god.name = "god";
		god.child.set(eve);
		god.children.asList().addAll(adams);
				
		god.insert();
		
		assertNotNull(god.id);
		assertNotNull(god.child.get().id);
		
		// get aggregated one2many
		AggregateParentModel godbis = AggregateParentModel.all().filter("name", "god").get();
		List<AggregateChildModel> children = godbis.children.asQuery().fetchKeys();
		for(int i=0; i<100; i++){
			assertEquals(adams.get(i).id, children.get(i).id);			
			assertTrue(children.get(i).name == null);			
		}
		
		for(int i=0; i<100; i++){
			assertEquals(adams.get(i), godbis.children.asList().get(i));			
		}
		
		Iterator<AggregateChildModel> it = godbis.children.asList().iterator();
		int i=0;
		while(it.hasNext()){
			AggregateChildModel child = it.next();
			assertEquals(adams.get(i++), child);	
		}
		assertEquals(100, i);
	}
	
	public void testAggregateListQuerysFetchKeysLimit() {
		List<AggregateChildModel> adams = new ArrayList<AggregateChildModel>();
		for(int i=0; i<100; i++){
			AggregateChildModel adam = new AggregateChildModel();
			adam.name = "adam"+i;
			adams.add(adam);
		}
		
		AggregateChildModel eve = new AggregateChildModel();
		eve.name = "eve";

		AggregateParentModel god = new AggregateParentModel();
		god.name = "god";
		god.child.set(eve);
		god.children.asList().addAll(adams);
				
		god.insert();
		
		assertNotNull(god.id);
		assertNotNull(god.child.get().id);
		
		// get aggregated one2many
		AggregateParentModel godbis = AggregateParentModel.all().filter("name", "god").get();
		List<AggregateChildModel> children = godbis.children.asQuery().fetchKeys(10);
		for(int i=0; i<10; i++){
			assertEquals(adams.get(i).id, children.get(i).id);			
			assertTrue(children.get(i).name == null);			
		}
		
		for(int i=0; i<100; i++){
			assertEquals(adams.get(i).id, godbis.children.asList().get(i).id);			
		}
		
		Iterator<AggregateChildModel> it = godbis.children.asList().iterator();
		int i=0;
		while(it.hasNext()){
			AggregateChildModel child = it.next();
			assertEquals(adams.get(i++).id, child.id);	
		}
		assertEquals(100, i);
	}
	
	public void testAggregateListQuerysFetchKeysLimitOffset() {
		List<AggregateChildModel> adams = new ArrayList<AggregateChildModel>();
		for(int i=0; i<100; i++){
			AggregateChildModel adam = new AggregateChildModel();
			adam.name = "adam"+i;
			adams.add(adam);
		}
		
		AggregateChildModel eve = new AggregateChildModel();
		eve.name = "eve";

		AggregateParentModel god = new AggregateParentModel();
		god.name = "god";
		god.child.set(eve);
		god.children.asList().addAll(adams);
				
		god.insert();
		
		assertNotNull(god.id);
		assertNotNull(god.child.get().id);
		
		// get aggregated one2many
		AggregateParentModel godbis = AggregateParentModel.all().filter("name", "god").get();
		List<AggregateChildModel> children = godbis.children.asQuery().fetchKeys(10, 26);
		for(int i=0; i<10; i++){
			assertEquals(adams.get(i+26).id, children.get(i).id);			
			assertTrue(children.get(i).name == null);			
		}
		
		for(int i=0; i<10; i++){
			assertEquals(adams.get(i).id, godbis.children.asList().get(i).id);			
		}
		
		Iterator<AggregateChildModel> it = godbis.children.asList().iterator();
		int i=0;
		while(it.hasNext()){
			AggregateChildModel child = it.next();
			assertEquals(adams.get(i++).id, child.id);	
		}
		assertEquals(100, i);
	}
	
	public void testAggregateListQueryDelete() {
		List<AggregateChildModel> adams = new ArrayList<AggregateChildModel>();
		for(int i=0; i<100; i++){
			AggregateChildModel adam = new AggregateChildModel();
			adam.name = "adam"+i;
			adams.add(adam);
		}
		
		AggregateChildModel eve = new AggregateChildModel();
		eve.name = "eve";

		AggregateParentModel god = new AggregateParentModel();
		god.name = "god";
		god.child.set(eve);
		god.children.asList().addAll(adams);
				
		god.insert();
		
		assertNotNull(god.id);
		assertNotNull(god.child.get().id);
		
		// get aggregated one2many
		AggregateParentModel godbis = AggregateParentModel.all().filter("name", "god").get();
		int nb = godbis.children.asQuery().delete();
		assertEquals(100, nb);			
		assertTrue( godbis.children.asList().isEmpty());			
		
		assertTrue( godbis.children.asQuery().fetch().isEmpty());			
		
		List<AggregateChildModel> children = AggregateChildModel.all().aggregated(god, "children").fetch();
		assertTrue(children.isEmpty());
	}
	
	public void testAggregateListQueryGet() {
		List<AggregateChildModel> adams = new ArrayList<AggregateChildModel>();
		for(int i=0; i<100; i++){
			AggregateChildModel adam = new AggregateChildModel();
			adam.name = "adam"+i;
			adams.add(adam);
		}
		
		AggregateChildModel eve = new AggregateChildModel();
		eve.name = "eve";

		AggregateParentModel god = new AggregateParentModel();
		god.name = "god";
		god.child.set(eve);
		god.children.asList().addAll(adams);
				
		god.insert();
		
		assertNotNull(god.id);
		assertNotNull(god.child.get().id);
		
		// get aggregated one2many
		AggregateParentModel godbis = AggregateParentModel.all().filter("name", "god").get();
		assertEquals( adams.get(0), godbis.children.asQuery().get());			
		assertEquals( adams.get(0), godbis.children.asList().get(0));			
		assertEquals( adams.get(0), godbis.children.asQuery().get());			

	}
	
	public void testAggregateListQueryCount() {
		List<AggregateChildModel> adams = new ArrayList<AggregateChildModel>();
		for(int i=0; i<100; i++){
			AggregateChildModel adam = new AggregateChildModel();
			adam.name = "adam"+i;
			adams.add(adam);
		}
		
		AggregateChildModel eve = new AggregateChildModel();
		eve.name = "eve";

		AggregateParentModel god = new AggregateParentModel();
		god.name = "god";
		god.child.set(eve);
		god.children.asList().addAll(adams);
				
		god.insert();
		
		assertNotNull(god.id);
		assertNotNull(god.child.get().id);
		
		// get aggregated one2many
		AggregateParentModel godbis = AggregateParentModel.all().filter("name", "god").get();
		assertEquals( adams.size(), godbis.children.asQuery().count());			
		assertEquals( adams.size(), godbis.children.asList().size());			
		assertEquals( adams.size(), godbis.children.asQuery().count());			

	}
	
	public void testAggregateListQueryFilter() {
		List<AggregateChildModel> adams = new ArrayList<AggregateChildModel>();
		for(int i=0; i<100; i++){
			AggregateChildModel adam = new AggregateChildModel();
			adam.name = "adam"+i;
			adams.add(adam);
		}
		
		AggregateChildModel eve = new AggregateChildModel();
		eve.name = "eve";

		AggregateParentModel god = new AggregateParentModel();
		god.name = "god";
		god.child.set(eve);
		god.children.asList().addAll(adams);
				
		god.insert();
		
		assertNotNull(god.id);
		assertNotNull(god.child.get().id);
		
		AggregateParentModel godbis = AggregateParentModel.all().filter("name", "god").get();
		AggregateChildModel adam47 = godbis.children.asQuery().filter("name", "adam47").get();
		assertEquals( adams.get(47), adam47);		

		List<AggregateChildModel> adamsbis = 
			godbis.children.asQuery().filter("name>", "adam47").filter("name<", "adam5").fetch();
		assertEquals( adams.get(48), adamsbis.get(0));		
		assertEquals( adams.get(49), adamsbis.get(1));		
	}
	
	public void testAggregateListQueryOrder() {
		List<AggregateChildModel> adams = new ArrayList<AggregateChildModel>();
		for(int i=0; i<100; i++){
			AggregateChildModel adam = new AggregateChildModel();
			adam.name = "adam"+i;
			adams.add(adam);
		}
		
		AggregateChildModel eve = new AggregateChildModel();
		eve.name = "eve";

		AggregateParentModel god = new AggregateParentModel();
		god.name = "god";
		god.child.set(eve);
		god.children.asList().addAll(adams);
				
		god.insert();
		
		assertNotNull(god.id);
		assertNotNull(god.child.get().id);
		
		AggregateParentModel godbis = AggregateParentModel.all().filter("name", "god").get();

		List<AggregateChildModel> adamsbis = 
			godbis.children.asQuery().filter("name>=", "adam41").filter("name<=", "adam49").order("-name").fetch();
		assertEquals( adams.get(49), adamsbis.get(0));		
		assertEquals( adams.get(48), adamsbis.get(1));		
		assertEquals( adams.get(47), adamsbis.get(2));		
		assertEquals( adams.get(46), adamsbis.get(3));		
		assertEquals( adams.get(45), adamsbis.get(4));		
		assertEquals( adams.get(44), adamsbis.get(5));		
		assertEquals( adams.get(43), adamsbis.get(6));		
		assertEquals( adams.get(42), adamsbis.get(7));		
		assertEquals( adams.get(41), adamsbis.get(8));		
	}
	
	public void testAggregateMostSimpleManual() {
		AggregateParentManualModel god = new AggregateParentManualModel("god");
		god.insert();
		assertNotNull(god.id);
		
		AggregateChildManualModel adam1 = new AggregateChildManualModel(123L, "adam1");
		adam1.aggregate(god, "child");
		adam1.insert();
		
		AggregateChildManualModel adam2 = new AggregateChildManualModel(0L, "adam2");	
		adam2.aggregate(god, "children");
		adam2.insert();

		AggregateChildManualModel eve = new AggregateChildManualModel(1L, "eve");
		eve.aggregate(god, "children");
		eve.insert();

		AggregateChildManualModel bob = new AggregateChildManualModel(2L, "bob");
		bob.aggregate(god, "children");
		bob.insert();

		
		AggregateChildManualModel adam1After = AggregateChildManualModel.all().aggregated(god, "child").get();
		assertEquals(adam1, adam1After);

		List<AggregateChildManualModel> children = AggregateChildManualModel.all().aggregated(god, "children").fetch();		
		assertEquals(adam2, children.get(0));
		assertEquals(eve, children.get(1));
		assertEquals(bob, children.get(2));
		
		AggregateChildManualModel adam1After2 = AggregateChildManualModel.all().aggregated(god, "child").filter("id", 123L).get();		
		assertEquals(adam1, adam1After2);

		AggregateChildManualModel eveAfter = AggregateChildManualModel.all().aggregated(god, "children").filter("id", 1L).get();		
		assertEquals(eve, eveAfter);
		
		eveAfter.name+="_UPD";
		eveAfter.update();
		AggregateChildManualModel eveAfter2 = AggregateChildManualModel.all().aggregated(god, "children").filter("id", 1L).get();
		assertEquals(eveAfter, eveAfter2);
		
		eveAfter2.name+="_UPD2";
		eveAfter2.save();
		AggregateChildManualModel eveAfter3 = AggregateChildManualModel.all().aggregated(god, "children").filter("id", 1L).get();
		assertEquals(eveAfter2, eveAfter3);
	}
	
	public void testAggregateDeleteParentFromQuery() {
		AggregateParentManualModel god = new AggregateParentManualModel("god");
		god.insert();
		assertNotNull(god.id);
		
		AggregateChildManualModel adam1 = new AggregateChildManualModel(123L, "adam1");
		adam1.aggregate(god, "child");
		adam1.insert();
		
		AggregateChildManualModel adam2 = new AggregateChildManualModel(0L, "adam2");	
		adam2.aggregate(god, "children");
		adam2.insert();

		AggregateChildManualModel eve = new AggregateChildManualModel(1L, "eve");
		eve.aggregate(god, "children");
		eve.insert();

		AggregateChildManualModel bob = new AggregateChildManualModel(2L, "bob");
		bob.aggregate(god, "children");
		bob.insert();
		
		int nb = AggregateParentManualModel.all().filter("name", "god").delete();
		assertEquals(5, nb);
		
		assertEquals(0, AggregateChildManualModel.all().aggregated(god, "children").count());
		assertEquals(0, AggregateChildManualModel.all().aggregated(god, "child").count());
		
	}

}