@Test
public void testAddingToList() {
PersonWithAList p = new PersonWithAList();
p.setFirstName("Sven");
p.setAge(22);
template.insert(p);
Query q1 = new Query(Criteria.where("id").is(p.getId()));
PersonWithAList p2 = template.findOne(q1, PersonWithAList.class);
assertThat(p2, notNullValue());
assertThat(p2.getWishList().size(), is(0));
p2.addToWishList("please work!");
template.save(p2);
PersonWithAList p3 = template.findOne(q1, PersonWithAList.class);
assertThat(p3, notNullValue());
assertThat(p3.getWishList().size(), is(1));
Friend f = new Friend();
p.setFirstName("Erik");
p.setAge(21);
p3.addFriend(f);
template.save(p3);
PersonWithAList p4 = template.findOne(q1, PersonWithAList.class);
assertThat(p4, notNullValue());
assertThat(p4.getWishList().size(), is(1));
assertThat(p4.getFriends().size(), is(1));
}
/** @see DATADOC-183 */
@Test
public void countsDocumentsCorrectly() {
assertThat(template.count(new Query(), Person.class), is(0L));
Person dave = new Person("Dave");
Person carter = new Person("Carter");
template.save(dave);
template.save(carter);
assertThat(template.count(null, Person.class), is(2L));
assertThat(template.count(query(where("firstName").is("Carter")), Person.class), is(1L));
}
/** @see DATADOC-230 */
@Test
public void removesEntityFromCollection() {
template.remove(new Query(), "mycollection");
Person person = new Person("Dave");
template.save(person, "mycollection");
assertThat(template.findAll(TestClass.class, "mycollection").size(), is(1));
template.remove(person, "mycollection");
assertThat(template.findAll(Person.class, "mycollection").isEmpty(), is(true));
}
@Test
public void returnsEntityWhenQueryingForDateTime() {
DateTime dateTime = new DateTime(2011, 3, 3, 12, 0, 0, 0);
TestClass testClass = new TestClass(dateTime);
mappingTemplate.save(testClass);
List<TestClass> testClassList =
mappingTemplate.find(
new Query(Criteria.where("myDate").is(dateTime.toDate())), TestClass.class);
assertThat(testClassList.size(), is(1));
assertThat(testClassList.get(0).myDate, is(testClass.myDate));
}
/** @see DATADOC-349 */
@Test
public void removesEntityWithAnnotatedIdIfIdNeedsMassaging() {
String id = new ObjectId().toString();
Sample sample = new Sample();
sample.id = id;
template.save(sample);
assertThat(template.findOne(query(where("id").is(id)), Sample.class).id, is(id));
template.remove(sample);
assertThat(template.findOne(query(where("id").is(id)), Sample.class), is(nullValue()));
}
/** @see DATADOC-240, DATADOC-212 */
@Test
public void updatesObjectIdsCorrectly() {
PersonWithIdPropertyOfTypeObjectId person = new PersonWithIdPropertyOfTypeObjectId();
person.setId(new ObjectId());
person.setFirstName("Dave");
template.save(person);
template.updateFirst(
query(where("id").is(person.getId())),
update("firstName", "Carter"),
PersonWithIdPropertyOfTypeObjectId.class);
PersonWithIdPropertyOfTypeObjectId result =
template.findById(person.getId(), PersonWithIdPropertyOfTypeObjectId.class);
assertThat(result, is(notNullValue()));
assertThat(result.getId(), is(person.getId()));
assertThat(result.getFirstName(), is("Carter"));
}
@Test
public void testWriteConcernResolver() {
PersonWithIdPropertyOfTypeObjectId person = new PersonWithIdPropertyOfTypeObjectId();
person.setId(new ObjectId());
person.setFirstName("Dave");
template.setWriteConcern(WriteConcern.NONE);
template.save(person);
WriteResult result =
template.updateFirst(
query(where("id").is(person.getId())),
update("firstName", "Carter"),
PersonWithIdPropertyOfTypeObjectId.class);
WriteConcern lastWriteConcern = result.getLastConcern();
assertThat(lastWriteConcern, equalTo(WriteConcern.NONE));
FsyncSafeWriteConcernResolver resolver = new FsyncSafeWriteConcernResolver();
template.setWriteConcernResolver(resolver);
Query q = query(where("_id").is(person.getId()));
Update u = update("firstName", "Carter");
result = template.updateFirst(q, u, PersonWithIdPropertyOfTypeObjectId.class);
lastWriteConcern = result.getLastConcern();
assertThat(lastWriteConcern, equalTo(WriteConcern.FSYNC_SAFE));
MongoAction lastMongoAction = resolver.getMongoAction();
assertThat(lastMongoAction.getCollectionName(), is("personWithIdPropertyOfTypeObjectId"));
assertThat(lastMongoAction.getDefaultWriteConcern(), equalTo(WriteConcern.NONE));
assertThat(lastMongoAction.getDocument(), notNullValue());
assertThat(
lastMongoAction.getEntityClass().toString(),
is(PersonWithIdPropertyOfTypeObjectId.class.toString()));
assertThat(lastMongoAction.getMongoActionOperation(), is(MongoActionOperation.UPDATE));
assertThat(lastMongoAction.getQuery(), equalTo(q.getQueryObject()));
assertThat(lastMongoAction.getDocument(), equalTo(u.getUpdateObject()));
}
private void testProperHandlingOfDifferentIdTypes(MongoTemplate mongoTemplate) throws Exception {
// String id - generated
PersonWithIdPropertyOfTypeString p1 = new PersonWithIdPropertyOfTypeString();
p1.setFirstName("Sven_1");
p1.setAge(22);
// insert
mongoTemplate.insert(p1);
// also try save
mongoTemplate.save(p1);
assertThat(p1.getId(), notNullValue());
PersonWithIdPropertyOfTypeString p1q =
mongoTemplate.findOne(
new Query(where("id").is(p1.getId())), PersonWithIdPropertyOfTypeString.class);
assertThat(p1q, notNullValue());
assertThat(p1q.getId(), is(p1.getId()));
checkCollectionContents(PersonWithIdPropertyOfTypeString.class, 1);
// String id - provided
PersonWithIdPropertyOfTypeString p2 = new PersonWithIdPropertyOfTypeString();
p2.setFirstName("Sven_2");
p2.setAge(22);
p2.setId("TWO");
// insert
mongoTemplate.insert(p2);
// also try save
mongoTemplate.save(p2);
assertThat(p2.getId(), notNullValue());
PersonWithIdPropertyOfTypeString p2q =
mongoTemplate.findOne(
new Query(where("id").is(p2.getId())), PersonWithIdPropertyOfTypeString.class);
assertThat(p2q, notNullValue());
assertThat(p2q.getId(), is(p2.getId()));
checkCollectionContents(PersonWithIdPropertyOfTypeString.class, 2);
// String _id - generated
PersonWith_idPropertyOfTypeString p3 = new PersonWith_idPropertyOfTypeString();
p3.setFirstName("Sven_3");
p3.setAge(22);
// insert
mongoTemplate.insert(p3);
// also try save
mongoTemplate.save(p3);
assertThat(p3.get_id(), notNullValue());
PersonWith_idPropertyOfTypeString p3q =
mongoTemplate.findOne(
new Query(where("_id").is(p3.get_id())), PersonWith_idPropertyOfTypeString.class);
assertThat(p3q, notNullValue());
assertThat(p3q.get_id(), is(p3.get_id()));
checkCollectionContents(PersonWith_idPropertyOfTypeString.class, 1);
// String _id - provided
PersonWith_idPropertyOfTypeString p4 = new PersonWith_idPropertyOfTypeString();
p4.setFirstName("Sven_4");
p4.setAge(22);
p4.set_id("FOUR");
// insert
mongoTemplate.insert(p4);
// also try save
mongoTemplate.save(p4);
assertThat(p4.get_id(), notNullValue());
PersonWith_idPropertyOfTypeString p4q =
mongoTemplate.findOne(
new Query(where("_id").is(p4.get_id())), PersonWith_idPropertyOfTypeString.class);
assertThat(p4q, notNullValue());
assertThat(p4q.get_id(), is(p4.get_id()));
checkCollectionContents(PersonWith_idPropertyOfTypeString.class, 2);
// ObjectId id - generated
PersonWithIdPropertyOfTypeObjectId p5 = new PersonWithIdPropertyOfTypeObjectId();
p5.setFirstName("Sven_5");
p5.setAge(22);
// insert
mongoTemplate.insert(p5);
// also try save
mongoTemplate.save(p5);
assertThat(p5.getId(), notNullValue());
PersonWithIdPropertyOfTypeObjectId p5q =
mongoTemplate.findOne(
new Query(where("id").is(p5.getId())), PersonWithIdPropertyOfTypeObjectId.class);
assertThat(p5q, notNullValue());
assertThat(p5q.getId(), is(p5.getId()));
checkCollectionContents(PersonWithIdPropertyOfTypeObjectId.class, 1);
// ObjectId id - provided
PersonWithIdPropertyOfTypeObjectId p6 = new PersonWithIdPropertyOfTypeObjectId();
p6.setFirstName("Sven_6");
p6.setAge(22);
p6.setId(new ObjectId());
// insert
mongoTemplate.insert(p6);
// also try save
mongoTemplate.save(p6);
assertThat(p6.getId(), notNullValue());
PersonWithIdPropertyOfTypeObjectId p6q =
mongoTemplate.findOne(
new Query(where("id").is(p6.getId())), PersonWithIdPropertyOfTypeObjectId.class);
assertThat(p6q, notNullValue());
assertThat(p6q.getId(), is(p6.getId()));
checkCollectionContents(PersonWithIdPropertyOfTypeObjectId.class, 2);
// ObjectId _id - generated
PersonWith_idPropertyOfTypeObjectId p7 = new PersonWith_idPropertyOfTypeObjectId();
p7.setFirstName("Sven_7");
p7.setAge(22);
// insert
mongoTemplate.insert(p7);
// also try save
mongoTemplate.save(p7);
assertThat(p7.get_id(), notNullValue());
PersonWith_idPropertyOfTypeObjectId p7q =
mongoTemplate.findOne(
new Query(where("_id").is(p7.get_id())), PersonWith_idPropertyOfTypeObjectId.class);
assertThat(p7q, notNullValue());
assertThat(p7q.get_id(), is(p7.get_id()));
checkCollectionContents(PersonWith_idPropertyOfTypeObjectId.class, 1);
// ObjectId _id - provided
PersonWith_idPropertyOfTypeObjectId p8 = new PersonWith_idPropertyOfTypeObjectId();
p8.setFirstName("Sven_8");
p8.setAge(22);
p8.set_id(new ObjectId());
// insert
mongoTemplate.insert(p8);
// also try save
mongoTemplate.save(p8);
assertThat(p8.get_id(), notNullValue());
PersonWith_idPropertyOfTypeObjectId p8q =
mongoTemplate.findOne(
new Query(where("_id").is(p8.get_id())), PersonWith_idPropertyOfTypeObjectId.class);
assertThat(p8q, notNullValue());
assertThat(p8q.get_id(), is(p8.get_id()));
checkCollectionContents(PersonWith_idPropertyOfTypeObjectId.class, 2);
// Integer id - provided
PersonWithIdPropertyOfTypeInteger p9 = new PersonWithIdPropertyOfTypeInteger();
p9.setFirstName("Sven_9");
p9.setAge(22);
p9.setId(Integer.valueOf(12345));
// insert
mongoTemplate.insert(p9);
// also try save
mongoTemplate.save(p9);
assertThat(p9.getId(), notNullValue());
PersonWithIdPropertyOfTypeInteger p9q =
mongoTemplate.findOne(
new Query(where("id").in(p9.getId())), PersonWithIdPropertyOfTypeInteger.class);
assertThat(p9q, notNullValue());
assertThat(p9q.getId(), is(p9.getId()));
checkCollectionContents(PersonWithIdPropertyOfTypeInteger.class, 1);
// int id - provided
PersonWithIdPropertyOfPrimitiveInt p10 = new PersonWithIdPropertyOfPrimitiveInt();
p10.setFirstName("Sven_10");
p10.setAge(22);
p10.setId(12345);
// insert
mongoTemplate.insert(p10);
// also try save
mongoTemplate.save(p10);
assertThat(p10.getId(), notNullValue());
PersonWithIdPropertyOfPrimitiveInt p10q =
mongoTemplate.findOne(
new Query(where("id").in(p10.getId())), PersonWithIdPropertyOfPrimitiveInt.class);
assertThat(p10q, notNullValue());
assertThat(p10q.getId(), is(p10.getId()));
checkCollectionContents(PersonWithIdPropertyOfPrimitiveInt.class, 1);
// Long id - provided
PersonWithIdPropertyOfTypeLong p11 = new PersonWithIdPropertyOfTypeLong();
p11.setFirstName("Sven_9");
p11.setAge(22);
p11.setId(Long.valueOf(12345L));
// insert
mongoTemplate.insert(p11);
// also try save
mongoTemplate.save(p11);
assertThat(p11.getId(), notNullValue());
PersonWithIdPropertyOfTypeLong p11q =
mongoTemplate.findOne(
new Query(where("id").in(p11.getId())), PersonWithIdPropertyOfTypeLong.class);
assertThat(p11q, notNullValue());
assertThat(p11q.getId(), is(p11.getId()));
checkCollectionContents(PersonWithIdPropertyOfTypeLong.class, 1);
// long id - provided
PersonWithIdPropertyOfPrimitiveLong p12 = new PersonWithIdPropertyOfPrimitiveLong();
p12.setFirstName("Sven_10");
p12.setAge(22);
p12.setId(12345L);
// insert
mongoTemplate.insert(p12);
// also try save
mongoTemplate.save(p12);
assertThat(p12.getId(), notNullValue());
PersonWithIdPropertyOfPrimitiveLong p12q =
mongoTemplate.findOne(
new Query(where("id").in(p12.getId())), PersonWithIdPropertyOfPrimitiveLong.class);
assertThat(p12q, notNullValue());
assertThat(p12q.getId(), is(p12.getId()));
checkCollectionContents(PersonWithIdPropertyOfPrimitiveLong.class, 1);
}