Added: labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/TransactionPartWritingTest.java URL: http://svn.apache.org/viewvc/labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/TransactionPartWritingTest.java?rev=1124229&view=auto ============================================================================== --- labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/TransactionPartWritingTest.java (added) +++ labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/TransactionPartWritingTest.java Wed May 18 12:46:03 2011 @@ -0,0 +1,184 @@ +package org.apache.magma.database.mongo; + +import static org.hamcrest.CoreMatchers.*; +import static org.junit.Assert.*; +import static org.apache.magma.database.mongo.test.utils.DBObjectMatcher.*; + +import org.apache.magma.database.mongo.test.domain.Address; +import org.apache.magma.database.mongo.test.domain.Car; +import org.apache.magma.database.mongo.test.domain.Person; +import org.apache.magma.database.mongo.test.domain.Person.PersonType; +import org.junit.Test; + + +public class TransactionPartWritingTest extends MongoDbTestBase { + + @Test + public void writeBasic() throws Exception { + Person p = new Person(); + p.setName("Simone"); + + db.save(p); + + mdb.checkAll(); + + mdb.getCollection("test", "person") + .expectInsert(dbObject("{'version': 1, '__transactions': [{'__transactionId' : '" + tr.getId() + "', 'name' :'Simone', '_jcl':'Person'}]}")); + + mdb.getCollection("test", "transactions") + .clearExpectations() + .expectInsert(dbObject("{'_id' : '" + tr.getId() + "', 'state':'R', 'entities' : {'person' : ['" + Long.toHexString(p.getId()) + "']} }")) + .expectUpdate(dbObject("{'_id' : '" + tr.getId() + "'}"),dbObject("{'$set': {'state':'D'}}")); + + + + db.commit(); + mdb.checkAll(); + + } + + // TODO test and implement exception cases + + @Test + public void writeUpdate() throws Exception { + + mdb.getCollection("test", "person") + .expectFindOne(dbObject("{'_id':'" + BSONPieces.simplePersonId + "'}"), cloneDbo(BSONPieces.simplePerson)); + + Person p = db.load(Person.class, BSONPieces.simplePersonId); + + mdb.checkAll(); + BSONPieces.assertSimplePersonLoaded(p); + + + p.setName("Mario"); + + db.save(p); + + mdb.checkAll(); + + mdb.getCollection("test", "person") + .expectUpdate( + dbObject("{'_id':'" + BSONPieces.simplePersonId + "', 'version' : 1}"), + dbObject("{'$push' : {'__transactions': {'__transactionId' : '" + tr.getId() + "', 'name' :'Mario'} }, '$set' : {'version': 2}}") + ); + + mdb.getCollection("test", "transactions") + .clearExpectations() + .expectInsert(dbObject("{'_id' : '" + tr.getId() + "', 'state':'R', 'entities' : {'person' : ['" + Long.toHexString(p.getId()) + "']} }")) + .expectUpdate(dbObject("{'_id' : '" + tr.getId() + "'}"),dbObject("{'$set': {'state':'D'}}")); + + + db.commit(); + mdb.checkAll(); + } + + @Test + public void writeCascade() throws Exception { + + Person p = new Person(); + p.setName("Simone"); + + Car c = new Car(); + p.setCar(c); + + c.setName("Buggy"); + + + db.save(p); + mdb.checkAll(); + + mdb.getCollection("test", "person") + .expectInsert(dbObject("{'version': 1, '__transactions': [{'__transactionId' : '" + tr.getId() + "', 'name' :'Simone', 'car' : '" + MongoUtils.getMongoId(c) + "', '_jcl':'Person'}]}")); + + mdb.getCollection("test", "car") + .expectInsert(dbObject("{'version': 1, '__transactions': [{'__transactionId' : '" + tr.getId() + "', 'name' :'Buggy', '_jcl':'Car'}]}")); + + mdb.getCollection("test", "transactions") + .clearExpectations() + .expectInsert(dbObject("{'_id' : '" + tr.getId() + "', 'state':'R', 'entities' : {'person' : ['" + Long.toHexString(p.getId()) + "'], 'car' : ['" + Long.toHexString(c.getId()) + "']} }")) + .expectUpdate(dbObject("{'_id' : '" + tr.getId() + "'}"),dbObject("{'$set': {'state':'D'}}")); + + db.commit(); + + mdb.checkAll(); + + } + + @Test + public void cascadeList() throws Exception { + Person p = new Person(); + p.setName("Simone"); + + Address a = new Address(); + p.getAddresses().add(a); + + a.setAddress("Via tiburtina 1238"); + + db.save(p); + + mdb.getCollection("test", "person") + .expectInsert(dbObject("{'version': 1, '__transactions': [{'__transactionId' : '" + tr.getId() + "', 'name' :'Simone', 'addresses': [ '" + MongoUtils.getMongoId(a) + "' ], '_jcl':'Person'}]}")); + + mdb.getCollection("test", "address") + .expectInsert(dbObject("{'version': 1, '__transactions': [{'__transactionId' : '" + tr.getId() + "', 'address' :'Via tiburtina 1238', '_jcl':'Address'}]}")); + + mdb.getCollection("test", "transactions") + .clearExpectations() + .expectInsert(dbObject("{'_id' : '" + tr.getId() + "', 'state':'R', 'entities' : {'person' : ['" + Long.toHexString(p.getId()) + "'], 'address' : ['" + Long.toHexString(a.getId()) + "']} }")) + .expectUpdate(dbObject("{'_id' : '" + tr.getId() + "'}"),dbObject("{'$set': {'state':'D'}}")); + + db.commit(); + + mdb.checkAll(); + } + + @Test + public void writeBoolean() throws Exception { + Person p = new Person(); + p.setBool(true); + + assertThat(p.isFromDb(), equalTo(false)); + assertThat(p.isOnDb(), equalTo(false)); + db.save(p); + assertThat(p.isFromDb(), equalTo(false)); + assertThat(p.isOnDb(), equalTo(true)); + + mdb.checkAll(); + + mdb.getCollection("test", "person") + .expectInsert(dbObject("{'version': 1, '__transactions': [{'__transactionId' : '" + tr.getId() + "', 'isBool' :true, '_jcl':'Person'}]}")); + + mdb.getCollection("test", "transactions") + .clearExpectations() + .expectInsert(dbObject("{'_id' : '" + tr.getId() + "', 'state':'R', 'entities' : {'person' : ['" + Long.toHexString(p.getId()) + "']} }")) + .expectUpdate(dbObject("{'_id' : '" + tr.getId() + "'}"),dbObject("{'$set': {'state':'D'}}")); + + db.commit(); + mdb.checkAll(); + + } + + @Test + public void writeEnum() throws Exception { + Person p = new Person(); + p.setType(PersonType.FRIENDLY); + + db.save(p); + + mdb.checkAll(); + + mdb.getCollection("test", "person") + .expectInsert(dbObject("{'version': 1, '__transactions': [{'__transactionId' : '" + tr.getId() + "', 'type' :'FRIENDLY', '_jcl':'Person'}]}")); + + mdb.getCollection("test", "transactions") + .clearExpectations() + .expectInsert(dbObject("{'_id' : '" + tr.getId() + "', 'state':'R', 'entities' : {'person' : ['" + Long.toHexString(p.getId()) + "']} }")) + .expectUpdate(dbObject("{'_id' : '" + tr.getId() + "'}"),dbObject("{'$set': {'state':'D'}}")); + + db.commit(); + mdb.checkAll(); + + } + +}
Added: labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/TransactionSecondPhaseTest.java URL: http://svn.apache.org/viewvc/labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/TransactionSecondPhaseTest.java?rev=1124229&view=auto ============================================================================== --- labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/TransactionSecondPhaseTest.java (added) +++ labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/TransactionSecondPhaseTest.java Wed May 18 12:46:03 2011 @@ -0,0 +1,195 @@ +package org.apache.magma.database.mongo; + +import static org.apache.magma.database.mongo.test.utils.DBObjectMatcher.dbObject; +import static org.hamcrest.CoreMatchers.*; +import static org.junit.matchers.JUnitMatchers.*; +import static org.junit.Assert.*; + +import org.apache.magma.database.mongo.TransactionSecondPhaseThread.Logger; +import org.apache.magma.database.mongo.test.domain.Person; +import org.apache.magma.database.mongo.test.utils.DBObjectMatcher; +import org.apache.magma.database.mongo.test.utils.MongoTestCursor; +import org.bson.BSONObject; +import org.junit.Test; + +import com.mongodb.BasicDBList; +import com.mongodb.BasicDBObject; +import com.mongodb.DBObject; +import com.mongodb.util.JSON; + + +public class TransactionSecondPhaseTest extends MongoDbTestBase { + + + @Test + public void newEntity() throws Exception { + Person p = new Person(); + p.setName("Simone"); + + db.save(p); + + mdb.checkAll(); + + DBObjectMatcher matchInsert = dbObject("{'version': 1, '__transactions': [{'__transactionId' : '" + tr.getId() + "', 'name' :'Simone', '_jcl':'Person'}]}"); + mdb.getCollection("test", "person") + .expectInsert(matchInsert); + + mdb.getCollection("test", "transactions") + .clearExpectations() + .expectInsert(dbObject("{'_id' : '" + tr.getId() + "', 'state':'R','entities' : {'person': ['" + Long.toHexString(p.getId()) + "'] } }")) + .expectUpdate(dbObject("{'_id' : '" + tr.getId() + "'}"),dbObject("{'$set': {'state':'D'}}")); + + + + db.commit(); + mdb.checkAll(); + + DBObject personInsert = matchInsert.getObtained(); + + TransactionSecondPhaseThread th = new TransactionSecondPhaseThread(mdb, "test"); + + try { + + mdb.getCollection("test", "transactions") + .expectRemove(dbObject("{'cstate':'D'}")) + .expectFind(new MongoTestCursor((DBObject)JSON.parse(("{'_id' : '" + tr.getId() + "', 'state':'D', 'entities' : {'person' : ['" + Long.toHexString(p.getId()) + "']} }").replace('\'', '"')))) + .expectUpdate(dbObject("{'_id' : '" + tr.getId() + "'}"),dbObject("{'$set': {'cstate':'C'}}")) + .expectUpdate(dbObject("{'_id' : '" + tr.getId() + "'}"),dbObject("{'$set': {'cstate':'D'}}")); + + mdb.getCollection("test", "person") + .expectFind(dbObject("{'_id': {'$in' : ['" + Long.toHexString(p.getId()) + "']}}"), personInsert) + .expectUpdate( + dbObject("{'_id':'" + Long.toHexString(p.getId()) + "', 'version' : 1}"), + dbObject("{'_id':'" + Long.toHexString(p.getId()) + "', 'version' : 2, 'name':'Simone','__transactions' : '_empty_'}") + ); + + th.poll(); + Logger pollres = th.getLogger(); + assertThat("Got errors : " + pollres.errors, pollres.errors, nullValue()); + assertThat("Got warnings : " + pollres.warnings, pollres.warnings, nullValue()); + assertThat(pollres.done, equalTo(1)); + assertThat(pollres.waiting, equalTo(0)); + assertThat(pollres.entitiesDone, equalTo(1)); + assertThat(pollres.entitiesSkip, equalTo(0)); + + mdb.checkAll(); + + } finally { + System.out.println(th.getLogger()); + } + } + + @Test + public void updateEntity() throws Exception { + mdb.getCollection("test", "person") + .expectFindOne(dbObject("{'_id':'" + BSONPieces.simplePersonId + "'}"), cloneDbo(BSONPieces.simplePerson)); + + Person p = db.load(Person.class, BSONPieces.simplePersonId); + + mdb.checkAll(); + BSONPieces.assertSimplePersonLoaded(p); + p.setName("Mario"); + p.setBirthday(null); + + db.save(p); + + mdb.checkAll(); + + DBObjectMatcher matchUpd = dbObject("{'$push' : {'__transactions': {'__transactionId' : '" + tr.getId() + "', 'name' :'Mario', 'birthday':'__NULL__'} }, '$set' : {'version': 2}}"); + + mdb.getCollection("test", "person") + .expectUpdate( + dbObject("{'_id':'" + BSONPieces.simplePersonId + "', 'version' : 1}"), + matchUpd + ); + + mdb.getCollection("test", "transactions") + .clearExpectations() + .expectInsert(dbObject("{'_id' : '" + tr.getId() + "', 'state':'R','entities' : {'person': ['" + Long.toHexString(p.getId()) + "']} }")) + .expectUpdate(dbObject("{'_id' : '" + tr.getId() + "'}"),dbObject("{'$set': {'state':'D'}}")); + + + db.commit(); + mdb.checkAll(); + + DBObject personupd = matchUpd.getObtained(); + + DBObject personbson = cloneDbo(p.checkGetBson()); + personbson.putAll((BSONObject) personupd.get("$set")); + BasicDBList trlist = new BasicDBList(); + trlist.add(((BSONObject)personupd.get("$push")).get("__transactions")); + personbson.put("__transactions", trlist); + + TransactionSecondPhaseThread th = new TransactionSecondPhaseThread(mdb, "test"); + + mdb.getCollection("test", "transactions") + .expectRemove(dbObject("{'cstate':'D'}")) + .expectFind(new MongoTestCursor((DBObject)JSON.parse(("{'_id' : '" + tr.getId() + "', 'state':'D', 'entities' : {'person' : ['" + Long.toHexString(p.getId()) + "']} }").replace('\'', '"')))) + .expectUpdate(dbObject("{'_id' : '" + tr.getId() + "'}"),dbObject("{'$set': {'cstate':'C'}}")) + .expectUpdate(dbObject("{'_id' : '" + tr.getId() + "'}"),dbObject("{'$set': {'cstate':'D'}}")); + + mdb.getCollection("test", "person") + .expectFind(dbObject("{'_id': {'$in' : ['" + Long.toHexString(p.getId()) + "']}}"), personbson) + .expectUpdate( + dbObject("{'_id':'" + Long.toHexString(p.getId()) + "', 'version' : 2}"), + dbObject("{'_id':'" + Long.toHexString(p.getId()) + "', 'version' : 3, 'name':'Mario', 'birthday':'__NOTPRESENT__','__transactions' : '_empty_'}") + ); + + th.poll(); + Logger pollres = th.getLogger(); + assertThat("Got errors : " + pollres.errors, pollres.errors, nullValue()); + assertThat("Got warnings : " + pollres.warnings, pollres.warnings, nullValue()); + assertThat(pollres.done, equalTo(1)); + assertThat(pollres.waiting, equalTo(0)); + assertThat(pollres.entitiesDone, equalTo(1)); + assertThat(pollres.entitiesSkip, equalTo(0)); + + mdb.checkAll(); + } + + // TODO check multiple entities + + @Test + public void deleteEntity() throws Exception { + BasicDBObject personInsert = new BasicDBObject(); + personInsert.putAll(BSONPieces.simplePerson); + personInsert.putAll((BSONObject)JSON.parse(("{" + + " '__transactions': [ {" + + " '__transactionId': '" + tr.getId() + "'," + + " '__deleted' : true" + + " }]" + + "}").replace('\'', '"'))); + + TransactionSecondPhaseThread th = new TransactionSecondPhaseThread(mdb, "test"); + + mdb.getCollection("test", "transactions") + .clearExpectations() + .expectRemove(dbObject("{'cstate':'D'}")) + .expectFind(new MongoTestCursor((DBObject)JSON.parse(("{'_id' : '" + tr.getId() + "', 'state':'D', 'entities' : {'person' : ['" + BSONPieces.simplePersonId + "']} }").replace('\'', '"')))) + .expectUpdate(dbObject("{'_id' : '" + tr.getId() + "'}"),dbObject("{'$set': {'cstate':'C'}}")) + .expectUpdate(dbObject("{'_id' : '" + tr.getId() + "'}"),dbObject("{'$set': {'cstate':'D'}}")); + + mdb.getCollection("test", "person") + .expectFind(dbObject("{'_id': {'$in' : ['" + BSONPieces.simplePersonId + "']}}"), personInsert) + .expectRemove(dbObject("{'_id':'" + BSONPieces.simplePersonId + "', 'version' : 1}")); + + th.poll(); + Logger pollres = th.getLogger(); + assertThat("Got errors : " + pollres.errors, pollres.errors, nullValue()); + assertThat("Got warnings : " + pollres.warnings, pollres.warnings, nullValue()); + assertThat(pollres.done, equalTo(1)); + assertThat(pollres.waiting, equalTo(0)); + assertThat(pollres.entitiesDone, equalTo(1)); + assertThat(pollres.entitiesSkip, equalTo(0)); + + mdb.checkAll(); + } + + // TODO check a failed transaction removal + + // TODO check one done transaction, one running and one failed + // first should apply, second should skip, third should be removed + + // TODO check the same in different order, what if the done one is the last one? + +} Added: labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/domain/Address.java URL: http://svn.apache.org/viewvc/labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/domain/Address.java?rev=1124229&view=auto ============================================================================== --- labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/domain/Address.java (added) +++ labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/domain/Address.java Wed May 18 12:46:03 2011 @@ -0,0 +1,40 @@ +package org.apache.magma.database.mongo.test.domain; + +import java.util.ArrayList; +import java.util.List; + +import javax.persistence.Entity; +import javax.persistence.ManyToOne; +import javax.persistence.OneToMany; + +@Entity +public class Address { + + private String address; + private City city; + private List<Address> neighborhood = new ArrayList<Address>(); + + public String getAddress() { + return address; + } + public void setAddress(String address) { + this.address = address; + } + + @ManyToOne + public City getCity() { + return city; + } + public void setCity(City city) { + this.city = city; + } + + @OneToMany + public List<Address> getNeighborhood() { + return neighborhood; + } + public void setNeighborhood(List<Address> neighborhood) { + this.neighborhood = neighborhood; + } + +} Added: labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/domain/Car.java URL: http://svn.apache.org/viewvc/labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/domain/Car.java?rev=1124229&view=auto ============================================================================== --- labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/domain/Car.java (added) +++ labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/domain/Car.java Wed May 18 12:46:03 2011 @@ -0,0 +1,34 @@ +package org.apache.magma.database.mongo.test.domain; + +import javax.persistence.Entity; +import javax.persistence.OneToOne; + +import org.apache.magma.database.LogicallyNamed; + +@Entity +public class Car implements LogicallyNamed { + + private String name; + private Person owner; + + public String getName() { + return name; + } + public void setName(String name) { + this.name = name; + } + + @OneToOne(mappedBy="car") + public Person getOwner() { + return owner; + } + public void setOwner(Person owner) { + this.owner = owner; + } + + public String computeLogicalName() { + return this.getName(); + } + + +} Added: labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/domain/City.java URL: http://svn.apache.org/viewvc/labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/domain/City.java?rev=1124229&view=auto ============================================================================== --- labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/domain/City.java (added) +++ labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/domain/City.java Wed May 18 12:46:03 2011 @@ -0,0 +1,28 @@ +package org.apache.magma.database.mongo.test.domain; + +import java.util.ArrayList; +import java.util.List; + +import javax.persistence.Entity; + +@Entity +public class City { + + private String name; + private List<String> notes = new ArrayList<String>(); + + + public String getName() { + return name; + } + public void setName(String name) { + this.name = name; + } + public List<String> getNotes() { + return notes; + } + public void setNotes(List<String> notes) { + this.notes = notes; + } + +} Added: labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/domain/ImportantPerson.java URL: http://svn.apache.org/viewvc/labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/domain/ImportantPerson.java?rev=1124229&view=auto ============================================================================== --- labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/domain/ImportantPerson.java (added) +++ labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/domain/ImportantPerson.java Wed May 18 12:46:03 2011 @@ -0,0 +1,102 @@ +package org.apache.magma.database.mongo.test.domain; + +import java.util.Date; +import java.util.List; +import java.util.Map; + +import javax.persistence.Entity; + +@Entity +public class ImportantPerson extends Person { + + private String importantBecause; + + private Map<String,Integer> scores; + private Map<Car,Long> garage; + private Map<Car,Person> drivers; + private Map<Date,City> travels; + private Map<String,Address> houses; + + public enum CCType { + AMEX, + VISA, + MASTERCARD + } + + private CCType mainCard; + private List<CCType> creditCards; + private Map<CCType,String> bonuses; + + public void setImportantBecause(String importantBecause) { + this.importantBecause = importantBecause; + } + + public String getImportantBecause() { + return importantBecause; + } + + public Map<String, Integer> getScores() { + return scores; + } + + public void setScores(Map<String, Integer> scores) { + this.scores = scores; + } + + public Map<Car, Long> getGarage() { + return garage; + } + + public void setGarage(Map<Car, Long> garage) { + this.garage = garage; + } + + public Map<Car, Person> getDrivers() { + return drivers; + } + + public void setDrivers(Map<Car, Person> drivers) { + this.drivers = drivers; + } + + public Map<Date, City> getTravels() { + return travels; + } + + public void setTravels(Map<Date, City> travels) { + this.travels = travels; + } + + public Map<String, Address> getHouses() { + return houses; + } + + public void setHouses(Map<String, Address> houses) { + this.houses = houses; + } + + public CCType getMainCard() { + return mainCard; + } + + public void setMainCard(CCType mainCard) { + this.mainCard = mainCard; + } + + public List<CCType> getCreditCards() { + return creditCards; + } + + public void setCreditCards(List<CCType> creditCards) { + this.creditCards = creditCards; + } + + public Map<CCType, String> getBonuses() { + return bonuses; + } + + public void setBonuses(Map<CCType, String> bonuses) { + this.bonuses = bonuses; + } + +} Added: labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/domain/NoDefaultId.java URL: http://svn.apache.org/viewvc/labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/domain/NoDefaultId.java?rev=1124229&view=auto ============================================================================== --- labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/domain/NoDefaultId.java (added) +++ labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/domain/NoDefaultId.java Wed May 18 12:46:03 2011 @@ -0,0 +1,24 @@ +package org.apache.magma.database.mongo.test.domain; + +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.Id; + +// FIXME currently a mongo _id is not given to entities not implementing WithDefaultId, it should be done for those with @GeneratedValue +@Entity +public class NoDefaultId { + + private long id; + + @Id + @GeneratedValue + public long getId() { + return id; + } + public void setId(long id) { + this.id = id; + } + + + +} Added: labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/domain/Person.java URL: http://svn.apache.org/viewvc/labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/domain/Person.java?rev=1124229&view=auto ============================================================================== --- labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/domain/Person.java (added) +++ labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/domain/Person.java Wed May 18 12:46:03 2011 @@ -0,0 +1,143 @@ +package org.apache.magma.database.mongo.test.domain; + +import java.util.ArrayList; +import java.util.Date; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.OneToMany; +import javax.persistence.OneToOne; +import javax.persistence.Transient; + +import org.apache.magma.database.LogicallyNamed; + +@Entity +public class Person implements LogicallyNamed { + + private String name; + private Date birthday; + private double height; + private long qi; + private boolean bool; + + private String cachedData; + + private Car car; + private Settings settings; + private Set<Person> friends = new HashSet<Person>(); + private List<Address> addresses = new ArrayList<Address>(); + private List<ToDo> todos = new ArrayList<ToDo>(); + + public enum PersonType { + FRIENDLY, + HATEFUL + } + + private PersonType type; + + + public String getName() { + return name; + } + public void setName(String name) { + this.name = name; + } + + + public Date getBirthday() { + return birthday; + } + public void setBirthday(Date birthday) { + this.birthday = birthday; + } + + + public double getHeight() { + return height; + } + public void setHeight(double height) { + this.height = height; + } + + + @Column(name="intelligence") + public long getQi() { + return qi; + } + public void setQi(long qi) { + this.qi = qi; + } + + + @Transient + public String getCachedData() { + return cachedData; + } + public void setCachedData(String cachedData) { + this.cachedData = cachedData; + } + + + @OneToMany(cascade=CascadeType.PERSIST) + public Set<Person> getFriends() { + return friends; + } + public void setFriends(Set<Person> friends) { + this.friends = friends; + } + + @OneToOne(cascade={CascadeType.PERSIST, CascadeType.REMOVE}) + public Car getCar() { + return car; + } + public void setCar(Car car) { + this.car = car; + } + + @OneToMany + public List<Address> getAddresses() { + return addresses; + } + public void setAddresses(List<Address> addresses) { + this.addresses = addresses; + } + + @OneToOne + public Settings getSettings() { + return settings; + } + public void setSettings(Settings settings) { + this.settings = settings; + } + public String computeLogicalName() { + return this.getName(); + } + + @OneToMany(cascade=CascadeType.ALL) + public List<ToDo> getTodos() { + return todos; + } + public void setTodos(List<ToDo> todos) { + this.todos = todos; + } + + @Column(name="isBool") + public boolean getBool() { + return bool; + } + public void setBool(boolean bool) { + this.bool = bool; + } + + public PersonType getType() { + return type; + } + public void setType(PersonType type) { + this.type = type; + } + +} Added: labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/domain/Settings.java URL: http://svn.apache.org/viewvc/labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/domain/Settings.java?rev=1124229&view=auto ============================================================================== --- labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/domain/Settings.java (added) +++ labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/domain/Settings.java Wed May 18 12:46:03 2011 @@ -0,0 +1,24 @@ +package org.apache.magma.database.mongo.test.domain; + +import javax.persistence.Entity; + +@Entity +public class Settings { + + private boolean likesCoffee; + private String greeting; + + public boolean isLikesCoffee() { + return likesCoffee; + } + public void setLikesCoffee(boolean likesCoffee) { + this.likesCoffee = likesCoffee; + } + public String getGreeting() { + return greeting; + } + public void setGreeting(String greeting) { + this.greeting = greeting; + } + +} Added: labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/domain/ToDo.java URL: http://svn.apache.org/viewvc/labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/domain/ToDo.java?rev=1124229&view=auto ============================================================================== --- labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/domain/ToDo.java (added) +++ labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/domain/ToDo.java Wed May 18 12:46:03 2011 @@ -0,0 +1,27 @@ +package org.apache.magma.database.mongo.test.domain; + +import javax.persistence.Entity; +import javax.persistence.ManyToOne; + +@Entity +public class ToDo { + + private String text; + private Person owner; + + public String getText() { + return text; + } + public void setText(String text) { + this.text = text; + } + + @ManyToOne + public Person getOwner() { + return owner; + } + public void setOwner(Person owner) { + this.owner = owner; + } + +} Added: labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/utils/DBObjectMatcher.java URL: http://svn.apache.org/viewvc/labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/utils/DBObjectMatcher.java?rev=1124229&view=auto ============================================================================== --- labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/utils/DBObjectMatcher.java (added) +++ labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/utils/DBObjectMatcher.java Wed May 18 12:46:03 2011 @@ -0,0 +1,159 @@ +package org.apache.magma.database.mongo.test.utils; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import java.util.Set; + +import junit.framework.AssertionFailedError; + +import org.bson.BSONObject; +import org.hamcrest.BaseMatcher; +import org.hamcrest.Description; +import org.hamcrest.Factory; + +import com.mongodb.BasicDBList; +import com.mongodb.BasicDBObject; +import com.mongodb.DBObject; +import com.mongodb.util.JSON; + +public class DBObjectMatcher extends BaseMatcher<DBObject> { + + private DBObject model; + private DBObject obtained; + private String error = ""; + + public DBObjectMatcher(DBObject model) { + this.model = model; + } + + public boolean matches(Object item) { + if (item == null) { + throw new AssertionFailedError("Was expecting a DBObject got null"); + } + if (!(item instanceof DBObject)) { + throw new AssertionFailedError("Was expecting a DBObject got " + item.getClass().getName()); + } + DBObject dbo = (DBObject) item; + this.obtained = new BasicDBObject(); + this.obtained.putAll(dbo); + return recurseCheck(model, dbo); + } + + public DBObject getObtained() { + return obtained; + } + + private boolean report(String msg) { + this.error += msg + "\n"; + return false; + } + + private boolean recurseCheck(DBObject m, DBObject dbo) { + Set<String> ks = m.keySet(); + for (String string : ks) { + Object v = m.get(string); + if (!dbo.containsField(string)) { + if (v.equals("__NOTPRESENT__")) continue; + return report(string + " is not present"); + } + if (v != null && v.equals("__NOTPRESENT__")) + return report(string + " is present while should not be there"); + + Object dbv = dbo.get(string); + if (dbv == null && v != null && !v.equals("__NULL__")) + return report(string + " is null"); + if ((v == null || v.equals("__NULL__")) && dbv != null) + return report(string + " is not null"); + if (v == null && dbv == null) continue; + if (dbv == null && v != null && v.equals("__NULL__")) continue; + if (v instanceof DBObject && !(v instanceof List)) { + if (!(dbv instanceof DBObject)) + return report(string + " is not a db object"); + if (!recurseCheck((DBObject)v, (DBObject)dbv)) { + return report("document " + string + " does not match"); + } else { + continue; + } + } + if (!checkEquals(v, dbv)) + return report(string + " has different value"); + } + return true; + } + + private boolean checkEquals(Object v, Object dbv) { + if (v instanceof Number) { + // Normalize them if they are numbers + v = ((Number)v).doubleValue(); + if (dbv instanceof Number) { + dbv = ((Number)dbv).doubleValue(); + return v.equals(dbv); + } else { + return report("not a number"); + } + } else if (v instanceof String) { + if (v.equals("_empty_")) { + if (!(dbv instanceof Collection)) + return report("not a collection"); + if (((Collection)dbv).size() != 0) + return report("not empty collection"); + return true; + } + if (!(dbv instanceof String)) + dbv = dbv.toString(); + if (((String) v).startsWith("_regexp_")) { + v = ((String)v).substring(8); + if (!((String)dbv).matches((String)v)) { + return report("does not match regex"); + } else { + return true; + } + } else { + return v.equals(dbv); + } + } else if (v instanceof List) { + // Lists are evaluated, as fields, as valid if they contain at least the given elements + // Elements are evaluated as other BSONObjects + if (!(dbv instanceof Collection)) + return report("not a collection"); + for (Object vo : (List)v) { + boolean found = false; + for (Object dbvo : (Collection)dbv) { + if (vo instanceof BSONObject) { + if (!(dbvo instanceof BSONObject)) + continue; + if (!recurseCheck((DBObject)vo, (DBObject)dbvo)) + continue; + } else { + if (!checkEquals(vo, dbvo)) + continue; + } + found = true; + break; + } + if (!found) + return report("not found '" + vo + "'"); + } + return true; + } + return v.equals(dbv); + } + + public void describeTo(Description description) { + if (this.error.length() > 0) description.appendText(error); + description.appendValue(model); + } + + @Factory + public static DBObjectMatcher dbObject(DBObject model) { + return new DBObjectMatcher(model); + } + + @Factory + public static DBObjectMatcher dbObject(String model) { + model = model.replace('\'', '"'); + return new DBObjectMatcher((DBObject) JSON.parse(model)); + } + +} Added: labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/utils/MongoTestCollection.java URL: http://svn.apache.org/viewvc/labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/utils/MongoTestCollection.java?rev=1124229&view=auto ============================================================================== --- labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/utils/MongoTestCollection.java (added) +++ labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/utils/MongoTestCollection.java Wed May 18 12:46:03 2011 @@ -0,0 +1,244 @@ +package org.apache.magma.database.mongo.test.utils; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +import junit.framework.AssertionFailedError; + +import org.apache.magma.database.mongo.MongoCollection; +import org.apache.magma.database.mongo.MongoCursor; +import org.hamcrest.Description; +import org.hamcrest.Matcher; +import org.hamcrest.StringDescription; +import static org.junit.Assert.assertThat; +import static org.hamcrest.CoreMatchers.*; + +import com.mongodb.BasicDBObject; +import com.mongodb.DBCollection; +import com.mongodb.DBCursor; +import com.mongodb.DBObject; +import com.mongodb.DummyResultFactory; +import com.mongodb.WriteConcern; +import com.mongodb.WriteResult; + +public class MongoTestCollection extends MongoCollection { + + private String dbname; + private String collname; + + public static class Expect { + public String methodName; + public Matcher[] args; + public Object retVal; + public boolean optional = false; + public boolean multiple = false; + public boolean happened = false; + + + public Expect(String methodName, Matcher[] args, Object retVal) { + this.methodName = methodName; + this.args = args; + this.retVal = retVal; + } + // XXX optional is currently not supported + public Expect(String methodName, Matcher[] args, Object retVal, boolean optional, boolean multiple) { + this(methodName, args, retVal); + this.multiple = multiple; + this.optional = optional; + } + + public void checkArgs(Object... received) { + this.happened = true; + StringDescription sd = new StringDescription(); + if (received.length > this.args.length) { + throw new AssertionFailedError("Expected call " + methodName + " with " + this.args.length + " params, got " + received.length + " params."); + } + for (int i = 0; i < this.args.length; i++) { + Object acval = null; + if (i < received.length) { + acval = received[i]; + } + assertThat("Check parameter " + i + " of " + this, acval, this.args[i]); + } + } + + @Override + public String toString() { + String ret = "Call to " + methodName + " with params ["; + for (Matcher<?> match : this.args) { + ret += StringDescription.toString(match); + } + ret += "]"; + return ret; + } + } + + private List<Expect> expect = new ArrayList<Expect>(); + + public MongoTestCollection clearExpectations() { + this.expect.clear(); + return this; + } + + public MongoTestCollection addExpectation(Expect exp) { + this.expect.add(exp); + return this; + } + + public void check() { + if (this.expect.size() > 0) { + boolean haserror = false; + String err = "Unsatisfied expect on " + this.dbname + ":" + this.collname + " : \n"; + for (Expect exp : this.expect) { + if (!exp.happened && !exp.optional) { + haserror = true; + err += exp.toString() + "\n"; + } + } + if (haserror) + throw new AssertionFailedError(err); + } + } + + public MongoTestCollection(String dbname, String collname) { + super(null); + this.dbname = dbname; + this.collname = collname; + } + + private <T> T checkExpect(String name, Object... params) { + boolean fail = this.expect.size() == 0; + Expect exp = null; + int i = 0; + while (!fail) { + // Get an expectation + exp = this.expect.get(i); + // Check the name + fail = !(exp.methodName.equals(name)); + // If the name is correct, check parameters + if (!fail) { + // Will throw exception is parameters are not correct + exp.checkArgs(params); + } + // If we get here, either everything is okay, or this call was not the one expected + // If the expectation was the right one, and is not multiple, remove it + if (!fail && !exp.multiple) { + this.expect.remove(i); + } + // If it was the right one, break + if (!fail) break; + // Unless it was optional, break here + if (!exp.optional) { + break; + } + // If it was optional, then try the next one + i++; + // If we reached the end, we failed + if (i >= this.expect.size()) { + fail = true; + } else { + fail = false; + } + } + if (fail) { + throw new AssertionFailedError("Unexpected call in " + this.dbname + ":" + this.collname + " : " + name + " " + Arrays.toString(params)); + } + return (T)exp.retVal; + } + + @Override + public DBObject findOne(DBObject query) { + return checkExpect("findOne", query); + } + public DBObject findOne(DBObject query, DBObject fields) { + return checkExpect("findOne", query, fields); + } + public MongoTestCollection expectFindOne(Matcher<? super DBObject> query, Matcher<? super DBObject> fields, DBObject ret) { + addExpectation(new Expect("findOne", new Matcher[]{query, fields}, ret)); + return this; + } + public MongoTestCollection expectFindOne(Matcher<? super DBObject> query, DBObject ret) { + return expectFindOne(query, anything(), ret); + } + @Override + public MongoCursor find(DBObject query) { + return checkExpect("find", query); + } + public MongoTestCollection expectFind(Matcher<? super DBObject> query, MongoTestCursor ret) { + addExpectation(new Expect("find", new Matcher[]{query}, ret)); + return this; + } + public MongoTestCollection expectFind(Matcher<? super DBObject> query, DBObject... objects) { + return expectFind(query, new MongoTestCursor(objects)); + } + + + @Override + public MongoCursor find() { + return checkExpect("find"); + } + public MongoTestCollection expectFind(MongoTestCursor ret) { + addExpectation(new Expect("find", new Matcher[0], ret)); + return this; + } + public MongoTestCollection expectFind(DBObject... ret) { + return expectFind(new MongoTestCursor(ret)); + } + + @Override + public String getFullName() { + return this.dbname + "." + this.collname; + } + + public String getName() { + return this.collname; + } + + + @Override + public WriteResult update(DBObject search, DBObject data, boolean upsert, boolean multi, WriteConcern writeConcern) { + return checkExpect("update", search, data, upsert, multi, writeConcern); + } + + public MongoTestCollection expectUpdate(Matcher<? super DBObject> search, Matcher<? super DBObject> data, Matcher<? super WriteConcern> concern, WriteResult ret) { + addExpectation(new Expect("update", new Matcher[] {search, data, anything(), anything(), concern}, ret)); + return this; + } + public MongoTestCollection expectUpdate(Matcher<? super DBObject> search, Matcher<? super DBObject> data) { + return expectUpdate(search, data, anything(), DummyResultFactory.ok(1)); + } + public MongoTestCollection expectUpdate(Matcher<? super DBObject> data) { + return expectUpdate(anything(), data, anything(), DummyResultFactory.ok(1)); + } + + @Override + public WriteResult insert(DBObject data, WriteConcern writeConcern) { + return checkExpect("insert", data, writeConcern); + } + + public MongoTestCollection expectInsert(Matcher<? super DBObject> data, Matcher<? super WriteConcern> concern, WriteResult ret) { + addExpectation(new Expect("insert", new Matcher[] {data, concern}, ret)); + return this; + } + public MongoTestCollection expectInsert(Matcher<? super DBObject> data) { + return expectInsert(data,notNullValue(), DummyResultFactory.ok(1)); + } + + @Override + public WriteResult remove(BasicDBObject search, WriteConcern writeConcern) { + return checkExpect("remove", search, writeConcern); + } + + public MongoTestCollection expectRemove(Matcher<? super DBObject> search, Matcher<? super WriteConcern> concern, WriteResult ret) { + addExpectation(new Expect("remove", new Matcher[] {search, concern}, ret)); + return this; + } + public MongoTestCollection expectRemove(Matcher<? super DBObject> search, WriteResult ret) { + return expectRemove(search, anything(), ret); + } + public MongoTestCollection expectRemove(Matcher<? super DBObject> search) { + return expectRemove(search, anything(), DummyResultFactory.ok(1)); + } + +} Added: labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/utils/MongoTestCursor.java URL: http://svn.apache.org/viewvc/labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/utils/MongoTestCursor.java?rev=1124229&view=auto ============================================================================== --- labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/utils/MongoTestCursor.java (added) +++ labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/utils/MongoTestCursor.java Wed May 18 12:46:03 2011 @@ -0,0 +1,67 @@ +package org.apache.magma.database.mongo.test.utils; + +import junit.framework.AssertionFailedError; + +import org.apache.magma.database.mongo.MongoCursor; + +import com.mongodb.DBCursor; +import com.mongodb.DBObject; + +public class MongoTestCursor extends MongoCursor { + + private DBObject[] objects; + private int index = 0; + private int min = 0; + private int max = 0; + private boolean closed; + + public MongoTestCursor(DBObject... objects) { + super(null); + this.objects = objects; + this.max = objects.length; + } + + @Override + public boolean hasNext() { + if (closed) throw new AssertionFailedError("Called hasNext on a closed cursor"); + return index < max && index < objects.length; + } + + @Override + public DBObject next() { + if (closed) throw new AssertionFailedError("Called next on a closed cursor"); + if (!hasNext()) throw new AssertionFailedError("Called next but all objects already sent"); + return objects[index++]; + } + + @Override + public void close() { + this.closed = true; + } + + @Override + public int count() { + return objects.length; + } + + @Override + public void skip(int from) { + index = from; + min = from; + } + + @Override + public void limit(int page) { + this.max = index + page; + } + + @Override + public int size() { + return this.max - this.min; + } + + @Override + public void sort(DBObject sort) { + } + +} Added: labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/utils/MongoTestDB.java URL: http://svn.apache.org/viewvc/labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/utils/MongoTestDB.java?rev=1124229&view=auto ============================================================================== --- labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/utils/MongoTestDB.java (added) +++ labs/magma/trunk/database-mongodb/src/test/java/org/apache/magma/database/mongo/test/utils/MongoTestDB.java Wed May 18 12:46:03 2011 @@ -0,0 +1,38 @@ +package org.apache.magma.database.mongo.test.utils; + +import java.util.HashMap; +import java.util.Map; + +import org.apache.magma.database.mongo.MongoDB; + +public class MongoTestDB extends MongoDB { + + public MongoTestDB() { + super(null); + } + + private Map<String, MongoTestCollection> collections = new HashMap<String, MongoTestCollection>(); + + @Override + public MongoTestCollection getCollection(String dbname, String collectionName) { + MongoTestCollection ret = collections.get(dbname + "__" + collectionName); + if (ret == null) { + ret = new MongoTestCollection(dbname, collectionName); + collections.put(dbname + "__" + collectionName, ret); + } + return ret; + } + + public void checkAll() { + for (MongoTestCollection coll : collections.values()) { + coll.check(); + } + } + + public void clearAllExpectations() { + for (MongoTestCollection coll : collections.values()) { + coll.clearExpectations(); + } + } + +} Added: labs/magma/trunk/database-mongodb/src/test/java/performanceTests/00_baseFunctions.js URL: http://svn.apache.org/viewvc/labs/magma/trunk/database-mongodb/src/test/java/performanceTests/00_baseFunctions.js?rev=1124229&view=auto ============================================================================== --- labs/magma/trunk/database-mongodb/src/test/java/performanceTests/00_baseFunctions.js (added) +++ labs/magma/trunk/database-mongodb/src/test/java/performanceTests/00_baseFunctions.js Wed May 18 12:46:03 2011 @@ -0,0 +1,74 @@ +var idprefix = 'AD12312ASD123'; +var reqdelay = 0; +var smallsInBig = 100; + +print("Deleting old objects"); +db.perfTest.remove(); +db.runCommand({fsync:1}); + +function request() { + sleep(reqdelay); +} + +function idSmall(i) { + return idprefix + 'S' + i; +} + +function makeSmallObj(i) { + return {_id:idSmall(i), name: "Simone", surname:"Gianni", type:"Small"}; +} + +function idBig(i) { + return idprefix + 'B' + i; +} + +function makeBigObj(i) { + var bigdoc = {_id:idSmall(i),name:"Test", type:"Big",_beans:[]}; + for (var i = 0;i < smallsInBig; i++) { + bigdoc._beans.push(makeSmallObj(i)); + } + return bigdoc; +} + +var start; + +function starting() { + start = new Date(); +} + +function elapsed(minus) { + var acd = new Date(); + var elaps = acd.getTime() - start.getTime(); + elaps -= minus; + return elaps; +} + +function timeReport(count, minusEach, fn) { + return timeReportFull(count, minusEach,fn)/count; +} + +function timeReportFull(count, minusEach, fn) { + starting(); + for (var i = 0; i < count; i++) { + fn(i); + } + db.runCommand({fsync:1}); + var elaps = elapsed(minusEach * count); + print( "Finished, took " + elaps + "ms, that is " + (elaps/count) + "ms each"); + return elaps; +} + +print( "Calculating generation time for big objects"); +starting(); +var bigOver = timeReport(5000, 0, function() { + makeBigObj(100); +}); + +print( "Calculating generation time for small objects"); +starting(); +var smallOver = timeReport(5000, 0, function() { + makeSmallObj(100); +}); + + + Added: labs/magma/trunk/database-mongodb/src/test/java/performanceTests/01_bigVsSmallCreate.js URL: http://svn.apache.org/viewvc/labs/magma/trunk/database-mongodb/src/test/java/performanceTests/01_bigVsSmallCreate.js?rev=1124229&view=auto ============================================================================== --- labs/magma/trunk/database-mongodb/src/test/java/performanceTests/01_bigVsSmallCreate.js (added) +++ labs/magma/trunk/database-mongodb/src/test/java/performanceTests/01_bigVsSmallCreate.js Wed May 18 12:46:03 2011 @@ -0,0 +1,28 @@ + +/* + +This test compare performances in creating a single big document vs creating many small ones. + +*/ +(function() { + print("---------------------------------------------------------------"); + print(" 01 - big documents vs small ones - creation"); + print("---------------------------------------------------------------"); + print( "Start of big document test, inserting 10000 big documents"); + starting(); + var bigs = timeReportFull(10000, bigOver, function(i) { + request(); + db.perfTest.save(makeBigObj(i)); + }); + + print( "Start of big document test, inserting " + (10000 * smallsInBig) + " small documents"); + starting(); + var smalls = timeReportFull((10000 * smallsInBig), smallOver, function(i) { + request(); + db.perfTest.save(makeSmallObj(i)); + }); + + print("Ratio : smalls takes " + (smalls/bigs) + " of the bigs time" ); +})(); + + Added: labs/magma/trunk/database-mongodb/src/test/java/performanceTests/02_bigVsSmallIdQuery.js URL: http://svn.apache.org/viewvc/labs/magma/trunk/database-mongodb/src/test/java/performanceTests/02_bigVsSmallIdQuery.js?rev=1124229&view=auto ============================================================================== --- labs/magma/trunk/database-mongodb/src/test/java/performanceTests/02_bigVsSmallIdQuery.js (added) +++ labs/magma/trunk/database-mongodb/src/test/java/performanceTests/02_bigVsSmallIdQuery.js Wed May 18 12:46:03 2011 @@ -0,0 +1,50 @@ +(function() { + print("---------------------------------------------------------------"); + print(" 02 - big documents vs small ones - id query"); + print("---------------------------------------------------------------"); + print( "Start of big document test, searching randomly 1000 documents"); + starting(); + var bigs = timeReportFull(1000, 0, function(i) { + var ri = Math.floor(Math.random() * 10000); + request(); + db.perfTest.findOne({_id:idBig(ri)}); + }); + + print( "Start of small document test, searching randomly 1000 documents"); + starting(); + var smalls = timeReportFull(1000, 0, function(i) { + var ri = Math.floor(Math.random() * (10000 * smallsInBig)); + request(); + db.perfTest.findOne({_id:idSmall(ri)}); + }); + print("Ratio : smalls takes " + (smalls/bigs) + " of the bigs time" ); + + function getRandomSmallIds(cnt) { + var ret = new Array(); + for (var j = 0; j < cnt; j++) { + var ri = Math.floor(Math.random() * (10000 * smallsInBig)); + ret.push(idSmall(ri)); + } + var dbo = {_id: { '$in' : ret}}; + return dbo; + } + + print( "Determining overhead of random ids generation"); + starting(); + var idsovr = timeReport(5000,0,function(i) { + getRandomSmallIds(10); + }); + + print( "Start of multiple small documents test, searching 1000 blocks of 10 small documents"); + starting(); + var smalls = timeReportFull(1000, idsovr, function(i) { + request(); + var q = getRandomSmallIds(10); + request(); + var res = db.perfTest.find(q); + while (res.hasNext()) { + res.next(); + } + }); + print("Ratio : smalls takes " + (smalls/bigs) + " of the bigs time" ); +})(); \ No newline at end of file --------------------------------------------------------------------- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
