@Autowired
  @SuppressWarnings("unchecked")
  public void setMongo(Mongo mongo) throws Exception {

    CustomConversions conversions =
        new CustomConversions(
            Arrays.asList(DateToDateTimeConverter.INSTANCE, DateTimeToDateConverter.INSTANCE));

    MongoMappingContext mappingContext = new MongoMappingContext();
    mappingContext.setInitialEntitySet(
        new HashSet<Class<?>>(
            Arrays.asList(
                PersonWith_idPropertyOfTypeObjectId.class,
                PersonWith_idPropertyOfTypeString.class,
                PersonWithIdPropertyOfTypeObjectId.class,
                PersonWithIdPropertyOfTypeString.class,
                PersonWithIdPropertyOfTypeInteger.class,
                PersonWithIdPropertyOfPrimitiveInt.class,
                PersonWithIdPropertyOfTypeLong.class,
                PersonWithIdPropertyOfPrimitiveLong.class)));
    mappingContext.setSimpleTypeHolder(conversions.getSimpleTypeHolder());
    mappingContext.afterPropertiesSet();

    MappingMongoConverter mappingConverter = new MappingMongoConverter(factory, mappingContext);
    mappingConverter.setCustomConversions(conversions);
    mappingConverter.afterPropertiesSet();

    this.mappingTemplate = new MongoTemplate(factory, mappingConverter);
  }
  @Autowired
  @SuppressWarnings("unchecked")
  public void setMongo(Mongo mongo) throws Exception {

    MongoMappingContext mappingContext = new MongoMappingContext();
    mappingContext.setInitialEntitySet(new HashSet<Class<?>>(Arrays.asList(ValueObject.class)));
    mappingContext.afterPropertiesSet();

    MappingMongoConverter mappingConverter = new MappingMongoConverter(factory, mappingContext);
    mappingConverter.afterPropertiesSet();
    this.mongoTemplate = new MongoTemplate(factory, mappingConverter);
  }
  /** @see DATAMONGO-404 */
  @Test(expected = MappingException.class)
  public void rejectsInvalidFieldReferenceForDbRef() {

    Update update = new Update().pull("dbRefAnnotatedList.name", "NAME");
    mapper.getMappedObject(
        update.getUpdateObject(), context.getPersistentEntity(DocumentWithDBRefCollection.class));
  }
  /** @see DATAMONGO-404 */
  @Test
  public void rendersNestedDbRefCorrectly() {

    Update update = new Update().pull("nested.dbRefAnnotatedList.id", "2");
    DBObject mappedObject =
        mapper.getMappedObject(
            update.getUpdateObject(), context.getPersistentEntity(Wrapper.class));

    DBObject pullClause = getAsDBObject(mappedObject, "$pull");
    assertThat(pullClause.containsField("mapped.dbRefAnnotatedList"), is(true));
  }
  /** @see DATAMONGO-862 */
  @Test
  public void rendersUpdateAndPreservesKeyForPathsNotPointingToProperty() {

    Update update = new Update().set("listOfInterface.$.value", "expected-value");
    DBObject mappedObject =
        mapper.getMappedObject(
            update.getUpdateObject(), context.getPersistentEntity(ParentClass.class));

    DBObject setClause = getAsDBObject(mappedObject, "$set");
    assertThat(setClause.containsField("listOfInterface.$.value"), is(true));
  }
  /** @see DATAMONGO-812 */
  @Test
  public void testUpdateShouldAllowMultiplePushEachForDifferentFields() {

    Update update =
        new Update().push("category").each("spring", "data").push("type").each("mongodb");
    DBObject mappedObject =
        mapper.getMappedObject(update.getUpdateObject(), context.getPersistentEntity(Object.class));

    DBObject push = getAsDBObject(mappedObject, "$push");
    assertThat(getAsDBObject(push, "category").containsField("$each"), is(true));
    assertThat(getAsDBObject(push, "type").containsField("$each"), is(true));
  }
  /** @see DATAMONGO-404 */
  @Test
  public void createsDbRefForEntityIdOnPulls() {

    Update update = new Update().pull("dbRefAnnotatedList.id", "2");

    DBObject mappedObject =
        mapper.getMappedObject(
            update.getUpdateObject(),
            context.getPersistentEntity(DocumentWithDBRefCollection.class));

    DBObject pullClause = getAsDBObject(mappedObject, "$pull");
    assertThat(pullClause.get("dbRefAnnotatedList"), is((Object) new DBRef(null, "entity", "2")));
  }
  /** @see DATAMONGO-807 */
  @Test
  public void updateMapperShouldNotPersistTypeInformationForNullValues() {

    Update update = Update.update("model", null);
    UpdateMapper mapper = new UpdateMapper(converter);

    DBObject mappedObject =
        mapper.getMappedObject(
            update.getUpdateObject(), context.getPersistentEntity(ModelWrapper.class));

    DBObject set = getAsDBObject(mappedObject, "$set");
    assertThat(set.get("_class"), nullValue());
  }
  /** @see DATAMONGO-812 */
  @Test
  public void updateMapperShouldConvertPushWhithoutAddingClassInformationWhenUsedWithEvery() {

    Update update = new Update().push("values").each("spring", "data", "mongodb");

    DBObject mappedObject =
        mapper.getMappedObject(update.getUpdateObject(), context.getPersistentEntity(Model.class));
    DBObject push = getAsDBObject(mappedObject, "$push");
    DBObject values = getAsDBObject(push, "values");

    assertThat(push.get("_class"), nullValue());
    assertThat(values.get("_class"), nullValue());
  }
  /** @see DATAMONGO-410 */
  @Test
  public void testUpdateMapperShouldConsiderCustomWriteTarget() {

    List<NestedEntity> someValues =
        Arrays.asList(
            new NestedEntity("spring"), new NestedEntity("data"), new NestedEntity("mongodb"));
    NestedEntity[] array = new NestedEntity[someValues.size()];

    Update update = new Update().pushAll("collectionOfNestedEntities", someValues.toArray(array));
    mapper.getMappedObject(
        update.getUpdateObject(), context.getPersistentEntity(DomainEntity.class));

    verify(writingConverterSpy, times(3)).convert(Mockito.any(NestedEntity.class));
  }
  /** @see DATAMONGO-807 */
  @Test
  public void updateMapperShouldRetainTypeInformationForNestedEntities() {

    Update update = Update.update("model", new ModelImpl(1));
    UpdateMapper mapper = new UpdateMapper(converter);

    DBObject mappedObject =
        mapper.getMappedObject(
            update.getUpdateObject(), context.getPersistentEntity(ModelWrapper.class));

    DBObject set = getAsDBObject(mappedObject, "$set");
    DBObject modelDbObject = (DBObject) set.get("model");
    assertThat(modelDbObject.get("_class"), not(nullValue()));
  }
  /** @see DATAMONGO-407 */
  @Test
  public void updateMapperShouldRetainTypeInformationForNestedCollectionElements() {

    Update update = Update.update("list.$", new ConcreteChildClass("42", "bubu"));

    UpdateMapper mapper = new UpdateMapper(converter);
    DBObject mappedObject =
        mapper.getMappedObject(
            update.getUpdateObject(), context.getPersistentEntity(ParentClass.class));

    DBObject set = getAsDBObject(mappedObject, "$set");
    DBObject modelDbObject = getAsDBObject(set, "aliased.$");
    assertThat(modelDbObject.get("_class"), is((Object) ConcreteChildClass.class.getName()));
  }
  /** @see DATAMONGO-407 */
  @Test
  public void updateMapperShouldSupportNestedCollectionElementUpdates() {

    Update update = Update.update("list.$.value", "foo").set("list.$.otherValue", "bar");

    UpdateMapper mapper = new UpdateMapper(converter);
    DBObject mappedObject =
        mapper.getMappedObject(
            update.getUpdateObject(), context.getPersistentEntity(ParentClass.class));

    DBObject set = getAsDBObject(mappedObject, "$set");
    assertThat(set.get("aliased.$.value"), is((Object) "foo"));
    assertThat(set.get("aliased.$.otherValue"), is((Object) "bar"));
  }
  /** @see DATAMONGO-721 */
  @Test
  public void updateMapperRetainsTypeInformationForCollectionField() {

    Update update = new Update().push("list", new ConcreteChildClass("2", "BAR"));

    DBObject mappedObject =
        mapper.getMappedObject(
            update.getUpdateObject(), context.getPersistentEntity(ParentClass.class));

    DBObject push = getAsDBObject(mappedObject, "$push");
    DBObject list = getAsDBObject(push, "aliased");

    assertThat(list.get("_class"), is((Object) ConcreteChildClass.class.getName()));
  }
  /** @see DATAMONGO-1077 */
  @Test
  public void shouldNotRemovePositionalParameter() {

    Update update = new Update();
    update.unset("dbRefAnnotatedList.$");

    DBObject mappedUpdate =
        mapper.getMappedObject(
            update.getUpdateObject(),
            context.getPersistentEntity(DocumentWithDBRefCollection.class));

    DBObject $unset = DBObjectTestUtils.getAsDBObject(mappedUpdate, "$unset");

    assertThat($unset, equalTo(new BasicDBObjectBuilder().add("dbRefAnnotatedList.$", 1).get()));
  }
  /** @see DATAMONGO-847 */
  @Test
  public void updateMapperConvertsPullWithNestedQuerfyOnDBRefCorrectly() {

    Update update =
        new Update().pull("dbRefAnnotatedList", Query.query(Criteria.where("id").is("1")));
    DBObject mappedUpdate =
        mapper.getMappedObject(
            update.getUpdateObject(),
            context.getPersistentEntity(DocumentWithDBRefCollection.class));

    DBObject $pull = DBObjectTestUtils.getAsDBObject(mappedUpdate, "$pull");
    DBObject list = DBObjectTestUtils.getAsDBObject($pull, "dbRefAnnotatedList");

    assertThat(list, equalTo(new BasicDBObjectBuilder().add("_id", "1").get()));
  }
  /** @see DATAMONGO-468 */
  @Test
  public void rendersUpdateOfDbRefPropertyWithDomainObjectCorrectly() {

    Entity entity = new Entity();
    entity.id = "5";

    Update update = new Update().set("dbRefProperty", entity);
    DBObject mappedObject =
        mapper.getMappedObject(
            update.getUpdateObject(),
            context.getPersistentEntity(DocumentWithDBRefCollection.class));

    DBObject setClause = getAsDBObject(mappedObject, "$set");
    assertThat(setClause.get("dbRefProperty"), is((Object) new DBRef(null, "entity", entity.id)));
  }
  /** @see DATAMONGO-943 */
  @Test
  public void updatePushEachAtPositionWorksCorrectlyWhenGivenPositionNull() {

    Update update =
        new Update().push("key").atPosition(null).each(Arrays.asList("Arya", "Arry", "Weasel"));

    DBObject mappedObject =
        mapper.getMappedObject(update.getUpdateObject(), context.getPersistentEntity(Object.class));

    DBObject push = getAsDBObject(mappedObject, "$push");
    DBObject key = getAsDBObject(push, "key");

    assertThat(key.containsField("$position"), is(false));
    assertThat(getAsDBObject(push, "key").containsField("$each"), is(true));
  }
  /** @see DATAMONGO-847 */
  @Test
  public void updateMapperConvertsNestedQueryCorrectly() {

    Update update =
        new Update().pull("list", Query.query(Criteria.where("value").in("foo", "bar")));
    DBObject mappedUpdate =
        mapper.getMappedObject(
            update.getUpdateObject(), context.getPersistentEntity(ParentClass.class));

    DBObject $pull = DBObjectTestUtils.getAsDBObject(mappedUpdate, "$pull");
    DBObject list = DBObjectTestUtils.getAsDBObject($pull, "aliased");
    DBObject value = DBObjectTestUtils.getAsDBObject(list, "value");
    BasicDBList $in = DBObjectTestUtils.getAsDBList(value, "$in");

    assertThat($in, IsIterableContainingInOrder.<Object>contains("foo", "bar"));
  }
  /** @see DATAMONG0-471 */
  @SuppressWarnings({"unchecked", "rawtypes"})
  @Test
  public void testUpdateShouldApply$addToSetCorrectlyWhenUsedWith$each() {

    Update update = new Update().addToSet("values").each("spring", "data", "mongodb");
    DBObject mappedObject =
        mapper.getMappedObject(
            update.getUpdateObject(), context.getPersistentEntity(ListModel.class));

    DBObject addToSet = getAsDBObject(mappedObject, "$addToSet");
    DBObject values = getAsDBObject(addToSet, "values");
    BasicDBList each = getAsDBList(values, "$each");

    assertThat(
        each.toMap(), (Matcher) allOf(hasValue("spring"), hasValue("data"), hasValue("mongodb")));
  }
  /** @see DATAMONGO-812 */
  @Test
  public void
      updateMapperShouldRetainClassInformationForPushCorrectlyWhenCalledWithEachUsingCustomTypes() {

    Update update = new Update().push("models").each(new ListModel("spring", "data", "mongodb"));
    DBObject mappedObject =
        mapper.getMappedObject(
            update.getUpdateObject(), context.getPersistentEntity(ModelWrapper.class));

    DBObject push = getAsDBObject(mappedObject, "$push");
    DBObject model = getAsDBObject(push, "models");
    BasicDBList each = getAsDBList(model, "$each");

    assertThat(
        ((DBObject) each.get(0)).get("_class").toString(), equalTo(ListModel.class.getName()));
  }
  /** @see DATAMONGO-897 */
  @Test
  public void
      updateOnDbrefPropertyOfInterfaceTypeWithoutExplicitGetterForIdShouldBeMappedCorrectly() {

    Update update =
        new Update().set("referencedDocument", new InterfaceDocumentDefinitionImpl("1", "Foo"));
    DBObject mappedObject =
        mapper.getMappedObject(
            update.getUpdateObject(),
            context.getPersistentEntity(DocumentWithReferenceToInterfaceImpl.class));

    DBObject $set = DBObjectTestUtils.getAsDBObject(mappedObject, "$set");
    Object model = $set.get("referencedDocument");

    DBRef expectedDBRef = new DBRef(factory.getDb(), "interfaceDocumentDefinitionImpl", "1");
    assertThat(model, allOf(instanceOf(DBRef.class), IsEqual.<Object>equalTo(expectedDBRef)));
  }
  /** @see DATAMONGO-812 */
  @SuppressWarnings({"unchecked", "rawtypes"})
  @Test
  public void updateMapperShouldConvertPushCorrectlyWhenCalledWithEachUsingCustomTypes() {

    Update update = new Update().push("models").each(new ListModel("spring", "data", "mongodb"));
    DBObject mappedObject =
        mapper.getMappedObject(
            update.getUpdateObject(), context.getPersistentEntity(ModelWrapper.class));

    DBObject push = getAsDBObject(mappedObject, "$push");
    DBObject model = getAsDBObject(push, "models");
    BasicDBList each = getAsDBList(model, "$each");
    BasicDBList values = getAsDBList((DBObject) each.get(0), "values");

    assertThat(
        values.toMap(), (Matcher) allOf(hasValue("spring"), hasValue("data"), hasValue("mongodb")));
  }
  /** @see DATAMONGO-407 */
  @Test
  public void updateMapperShouldWriteTypeInformationForComplexNestedCollectionElementUpdates() {

    Update update =
        Update.update("list.$.value", "foo")
            .set("list.$.someObject", new ConcreteChildClass("42", "bubu"));

    UpdateMapper mapper = new UpdateMapper(converter);
    DBObject mappedObject =
        mapper.getMappedObject(
            update.getUpdateObject(), context.getPersistentEntity(ParentClass.class));

    DBObject dbo = getAsDBObject(mappedObject, "$set");
    assertThat(dbo.get("aliased.$.value"), is((Object) "foo"));

    DBObject someObject = getAsDBObject(dbo, "aliased.$.someObject");
    assertThat(someObject, is(notNullValue()));
    assertThat(someObject.get("_class"), is((Object) ConcreteChildClass.class.getName()));
    assertThat(someObject.get("value"), is((Object) "bubu"));
  }
  /** @see DATAMONGO-863 */
  @Test
  public void doesNotConvertRawDbObjects() {

    Update update = new Update();
    update.pull(
        "options",
        new BasicDBObject(
            "_id", new BasicDBObject("$in", converter.convertToMongoType(Arrays.asList(1L, 2L)))));

    DBObject mappedObject =
        mapper.getMappedObject(
            update.getUpdateObject(), context.getPersistentEntity(ParentClass.class));

    DBObject setClause = getAsDBObject(mappedObject, "$pull");
    DBObject options = getAsDBObject(setClause, "options");
    DBObject idClause = getAsDBObject(options, "_id");
    BasicDBList inClause = getAsDBList(idClause, "$in");

    assertThat(inClause, IsIterableContainingInOrder.<Object>contains(1L, 2L));
  }
  /** @see DATAMONG0-471 */
  @Test
  public void
      testUpdateShouldRetainClassTypeInformationWhenUsing$addToSetWith$eachForCustomTypes() {

    Update update =
        new Update()
            .addToSet("models")
            .each(new ModelImpl(2014), new ModelImpl(1), new ModelImpl(28));
    DBObject mappedObject =
        mapper.getMappedObject(
            update.getUpdateObject(), context.getPersistentEntity(ModelWrapper.class));

    DBObject addToSet = getAsDBObject(mappedObject, "$addToSet");

    DBObject values = getAsDBObject(addToSet, "models");
    BasicDBList each = getAsDBList(values, "$each");

    for (Object updateValue : each) {
      assertThat(
          ((DBObject) updateValue).get("_class").toString(),
          equalTo("org.springframework.data.mongodb.core.convert.UpdateMapperUnitTests$ModelImpl"));
    }
  }