DATAMONGO-860 - Release version 1.4.1.RELEASE (Codd SR1).

Update readme.md & mongodb.xml to reflect recent version. Update sd-commons/sb-build versions in pom.xml. Update pom.xml to use release repository.
Update docbkx to use recent sd-commons version. Update changelog to reflect changes and releases.

Original Pull Request: #148.

README.md

@@ -26,7 +26,7 @@ Add the Maven dependency:
 <dependency>
   <groupId>org.springframework.data</groupId>
   <artifactId>spring-data-mongodb</artifactId>
-  <version>1.4.0.RELEASE</version>
+  <version>1.4.1.RELEASE</version>
 </dependency>
 ```
 

pom.xml

@@ -5,7 +5,7 @@
 	
 	<groupId>org.springframework.data</groupId>
 	<artifactId>spring-data-mongodb-parent</artifactId>
-	<version>1.4.0.RELEASE</version>
+	<version>1.4.1.RELEASE</version>
 	<packaging>pom</packaging>
 
 	<name>Spring Data MongoDB</name>
@@ -15,7 +15,7 @@
 	<parent>
 		<groupId>org.springframework.data.build</groupId>
 		<artifactId>spring-data-parent</artifactId>
-		<version>1.3.0.RELEASE</version>
+		<version>1.3.1.RELEASE</version>
 		<relativePath>../spring-data-build/parent/pom.xml</relativePath>
 	</parent>
 	
@@ -29,7 +29,7 @@
 	<properties>
 		<project.type>multi</project.type>
 		<dist.id>spring-data-mongodb</dist.id>
-		<springdata.commons>1.7.0.RELEASE</springdata.commons>
+		<springdata.commons>1.7.1.RELEASE</springdata.commons>
 		<mongo>2.11.4</mongo>
 		<mongo-osgi>${mongo}</mongo-osgi>
 	</properties>

spring-data-mongodb-cross-store/pom.xml

@@ -6,7 +6,7 @@
 	<parent>
 		<groupId>org.springframework.data</groupId>
 		<artifactId>spring-data-mongodb-parent</artifactId>
-		<version>1.4.0.RELEASE</version>
+		<version>1.4.1.RELEASE</version>
 		<relativePath>../pom.xml</relativePath>
 	</parent>
 	
@@ -48,7 +48,7 @@
 		<dependency>
 			<groupId>org.springframework.data</groupId>
 			<artifactId>spring-data-mongodb</artifactId>
-			<version>1.4.0.RELEASE</version>
+			<version>1.4.1.RELEASE</version>
 		</dependency>
 
 		<dependency>

spring-data-mongodb-distribution/pom.xml

@@ -13,7 +13,7 @@
 	<parent>
 		<groupId>org.springframework.data</groupId>
 		<artifactId>spring-data-mongodb-parent</artifactId>
-		<version>1.4.0.RELEASE</version>
+		<version>1.4.1.RELEASE</version>
 		<relativePath>../pom.xml</relativePath>
 	</parent>
 	

spring-data-mongodb-log4j/pom.xml

@@ -5,7 +5,7 @@
 	<parent>
 		<groupId>org.springframework.data</groupId>
 		<artifactId>spring-data-mongodb-parent</artifactId>
-		<version>1.4.0.RELEASE</version>
+		<version>1.4.1.RELEASE</version>
 		<relativePath>../pom.xml</relativePath>
 	</parent>
 

spring-data-mongodb/pom.xml

@@ -11,7 +11,7 @@
 	<parent>
 		<groupId>org.springframework.data</groupId>
 		<artifactId>spring-data-mongodb-parent</artifactId>
-		<version>1.4.0.RELEASE</version>
+		<version>1.4.1.RELEASE</version>
 		<relativePath>../pom.xml</relativePath>
 	</parent>
 
@@ -137,6 +137,13 @@
 			<scope>test</scope>
 		</dependency>
 		
+		<dependency>
+			<groupId>org.slf4j</groupId>
+			<artifactId>jul-to-slf4j</artifactId>
+			<version>${slf4j}</version>
+			<scope>test</scope>
+		</dependency>
+		
 	</dependencies>
 	
 	<build>

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/config/AbstractMongoConfiguration.java

@@ -116,7 +116,9 @@ public abstract class AbstractMongoConfiguration {
 	 *         entities.
 	 */
 	protected String getMappingBasePackage() {
-		return getClass().getPackage().getName();
+
+		Package mappingBasePackage = getClass().getPackage();
+		return mappingBasePackage == null ? null : mappingBasePackage.getName();
 	}
 
 	/**

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/config/MongoAuditingRegistrar.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013 the original author or authors.
+ * Copyright 2013-2014 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,17 +15,24 @@
  */
 package org.springframework.data.mongodb.config;
 
+import static org.springframework.beans.factory.config.BeanDefinition.*;
+import static org.springframework.data.mongodb.config.BeanNames.*;
+
 import java.lang.annotation.Annotation;
 
 import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.beans.factory.support.AbstractBeanDefinition;
 import org.springframework.beans.factory.support.BeanDefinitionBuilder;
 import org.springframework.beans.factory.support.BeanDefinitionRegistry;
+import org.springframework.beans.factory.support.RootBeanDefinition;
 import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
 import org.springframework.core.type.AnnotationMetadata;
 import org.springframework.data.auditing.IsNewAwareAuditingHandler;
 import org.springframework.data.auditing.config.AnnotationAuditingConfiguration;
 import org.springframework.data.auditing.config.AuditingBeanDefinitionRegistrarSupport;
+import org.springframework.data.config.ParsingUtils;
 import org.springframework.data.mapping.context.MappingContextIsNewStrategyFactory;
+import org.springframework.data.mongodb.core.mapping.MongoMappingContext;
 import org.springframework.data.mongodb.core.mapping.event.AuditingEventListener;
 import org.springframework.data.support.IsNewStrategyFactory;
 import org.springframework.util.Assert;
@@ -57,7 +64,7 @@ class MongoAuditingRegistrar extends AuditingBeanDefinitionRegistrarSupport {
 		Assert.notNull(annotationMetadata, "AnnotationMetadata must not be null!");
 		Assert.notNull(registry, "BeanDefinitionRegistry must not be null!");
 
-		registerIsNewStrategyFactoryIfNecessary(registry);
+		defaultDependenciesIfNecessary(registry, annotationMetadata);
 		super.registerBeanDefinitions(annotationMetadata, registry);
 	}
 
@@ -92,14 +99,33 @@ class MongoAuditingRegistrar extends AuditingBeanDefinitionRegistrarSupport {
 	}
 
 	/**
-	 * @param registry, the {@link BeanDefinitionRegistry} to use to register an {@link IsNewStrategyFactory} to.
+	 * Register default bean definitions for a {@link MongoMappingContext} and an {@link IsNewStrategyFactory} in case we
+	 * don't find beans with the assumed names in the registry.
+	 * 
+	 * @param registry the {@link BeanDefinitionRegistry} to use to register the components into.
+	 * @param source the source which the registered components shall be registered with
 	 */
-	private void registerIsNewStrategyFactoryIfNecessary(BeanDefinitionRegistry registry) {
+	private void defaultDependenciesIfNecessary(BeanDefinitionRegistry registry, Object source) {
 
-		if (!registry.containsBeanDefinition(BeanNames.IS_NEW_STRATEGY_FACTORY)) {
-			registry.registerBeanDefinition(BeanNames.IS_NEW_STRATEGY_FACTORY,
-					BeanDefinitionBuilder.rootBeanDefinition(MappingContextIsNewStrategyFactory.class)
-							.addConstructorArgReference(BeanNames.MAPPING_CONTEXT).getBeanDefinition());
+		if (!registry.containsBeanDefinition(MAPPING_CONTEXT)) {
+
+			RootBeanDefinition definition = new RootBeanDefinition(MongoMappingContext.class);
+			definition.setRole(ROLE_INFRASTRUCTURE);
+			definition.setSource(source);
+
+			registry.registerBeanDefinition(MAPPING_CONTEXT, definition);
+		}
+
+		if (!registry.containsBeanDefinition(IS_NEW_STRATEGY_FACTORY)) {
+
+			BeanDefinitionBuilder builder = BeanDefinitionBuilder
+					.rootBeanDefinition(MappingContextIsNewStrategyFactory.class);
+			builder.addConstructorArgReference(MAPPING_CONTEXT);
+
+			AbstractBeanDefinition definition = ParsingUtils.getSourceBeanDefinition(builder, source);
+			definition.setRole(ROLE_INFRASTRUCTURE);
+
+			registry.registerBeanDefinition(IS_NEW_STRATEGY_FACTORY, definition);
 		}
 	}
 }

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/MongoTemplate.java

@@ -1573,6 +1573,8 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 
 		MongoPersistentEntity<?> entity = mappingContext.getPersistentEntity(entityClass);
 
+		increaseVersionForUpdateIfNecessary(entity, update);
+
 		DBObject mappedQuery = queryMapper.getMappedObject(query, entity);
 		DBObject mappedUpdate = updateMapper.getMappedObject(update.getUpdateObject(), entity);
 

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/convert/MappingMongoConverter.java

@@ -19,6 +19,8 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.EnumMap;
+import java.util.EnumSet;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
@@ -794,7 +796,7 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 	 * @param sourceValue must not be {@literal null}.
 	 * @return the converted {@link Collection} or array, will never be {@literal null}.
 	 */
-	@SuppressWarnings("unchecked")
+	@SuppressWarnings({ "unchecked", "null" })
 	private Object readCollectionOrArray(TypeInformation<?> targetType, BasicDBList sourceValue, Object parent) {
 
 		Assert.notNull(targetType);
@@ -807,11 +809,20 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 
 		collectionType = Collection.class.isAssignableFrom(collectionType) ? collectionType : List.class;
 
-		Collection<Object> items = targetType.getType().isArray() ? new ArrayList<Object>() : CollectionFactory
-				.createCollection(collectionType, sourceValue.size());
 		TypeInformation<?> componentType = targetType.getComponentType();
 		Class<?> rawComponentType = componentType == null ? null : componentType.getType();
 
+		Collection<Object> items;
+
+		if (targetType.getType().isArray()) {
+			items = new ArrayList<Object>();
+		} else if (EnumSet.class.isAssignableFrom(collectionType)) {
+			Assert.notNull(rawComponentType, "Component type must not be null for enum sets!");
+			items = EnumSet.noneOf(rawComponentType.asSubclass(Enum.class));
+		} else {
+			items = CollectionFactory.createCollection(collectionType, sourceValue.size());
+		}
+
 		for (int i = 0; i < sourceValue.size(); i++) {
 
 			Object dbObjItem = sourceValue.get(i);
@@ -836,31 +847,43 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 	 * @param dbObject
 	 * @return
 	 */
-	@SuppressWarnings("unchecked")
+	@SuppressWarnings({ "unchecked", "null", "rawtypes" })
 	protected Map<Object, Object> readMap(TypeInformation<?> type, DBObject dbObject, Object parent) {
 
 		Assert.notNull(dbObject);
 
 		Class<?> mapType = typeMapper.readType(dbObject, type).getType();
-		Map<Object, Object> map = CollectionFactory.createMap(mapType, dbObject.keySet().size());
+
+		TypeInformation<?> keyType = type.getComponentType();
+		Class<?> rawKeyType = keyType == null ? null : keyType.getType();
+
+		TypeInformation<?> valueType = type.getMapValueType();
+		Class<?> rawValueType = valueType == null ? null : valueType.getType();
+
+		Map<Object, Object> map;
+
+		if (EnumMap.class.isAssignableFrom(mapType)) {
+			Assert.notNull(keyType, "Key type must nut be null for enum maps!");
+			map = new EnumMap(rawKeyType.asSubclass(Enum.class));
+		} else {
+			map = CollectionFactory.createMap(mapType, dbObject.keySet().size());
+		}
+
 		Map<String, Object> sourceMap = dbObject.toMap();
 
 		for (Entry<String, Object> entry : sourceMap.entrySet()) {
+
 			if (typeMapper.isTypeKey(entry.getKey())) {
 				continue;
 			}
 
 			Object key = potentiallyUnescapeMapKey(entry.getKey());
 
-			TypeInformation<?> keyTypeInformation = type.getComponentType();
-			if (keyTypeInformation != null) {
-				Class<?> keyType = keyTypeInformation.getType();
-				key = conversionService.convert(key, keyType);
+			if (rawKeyType != null) {
+				key = conversionService.convert(key, rawKeyType);
 			}
 
 			Object value = entry.getValue();
-			TypeInformation<?> valueType = type.getMapValueType();
-			Class<?> rawValueType = valueType == null ? null : valueType.getType();
 
 			if (value instanceof DBObject) {
 				map.put(key, read(valueType, (DBObject) value, parent));

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/convert/QueryMapper.java

@@ -138,7 +138,7 @@ public class QueryMapper {
 			value = getMappedValue(field, rawValue);
 		}
 
-		return Collections.singletonMap(key, value).entrySet().iterator().next();
+		return createMapEntry(key, value);
 	}
 
 	/**
@@ -168,7 +168,7 @@ public class QueryMapper {
 			BasicDBList newConditions = new BasicDBList();
 
 			for (Object condition : conditions) {
-				newConditions.add(condition instanceof DBObject ? getMappedObject((DBObject) condition, entity)
+				newConditions.add(isDBObject(condition) ? getMappedObject((DBObject) condition, entity)
 						: convertSimpleOrDBObject(condition, entity));
 			}
 
@@ -209,7 +209,7 @@ public class QueryMapper {
 
 		if (documentField.isIdField()) {
 
-			if (value instanceof DBObject) {
+			if (isDBObject(value)) {
 				DBObject valueDbo = (DBObject) value;
 				DBObject resultDbo = new BasicDBObject(valueDbo.toMap());
 
@@ -267,13 +267,13 @@ public class QueryMapper {
 	 * @param entity
 	 * @return
 	 */
-	private Object convertSimpleOrDBObject(Object source, MongoPersistentEntity<?> entity) {
+	protected Object convertSimpleOrDBObject(Object source, MongoPersistentEntity<?> entity) {
 
 		if (source instanceof BasicDBList) {
 			return delegateConvertToMongoType(source, entity);
 		}
 
-		if (source instanceof DBObject) {
+		if (isDBObject(source)) {
 			return getMappedObject((DBObject) source, entity);
 		}
 
@@ -305,7 +305,7 @@ public class QueryMapper {
 	 */
 	protected Object convertAssociation(Object source, MongoPersistentProperty property) {
 
-		if (property == null || source == null || source instanceof DBRef) {
+		if (property == null || source == null || source instanceof DBRef || source instanceof DBObject) {
 			return source;
 		}
 
@@ -329,6 +329,40 @@ public class QueryMapper {
 		return createDbRefFor(source, property);
 	}
 
+	/**
+	 * Checks whether the given value is a {@link DBObject}.
+	 * 
+	 * @param value can be {@literal null}.
+	 * @return
+	 */
+	protected final boolean isDBObject(Object value) {
+		return value instanceof DBObject;
+	}
+
+	/**
+	 * Creates a new {@link Entry} for the given {@link Field} with the given value.
+	 * 
+	 * @param field must not be {@literal null}.
+	 * @param value can be {@literal null}.
+	 * @return
+	 */
+	protected final Entry<String, Object> createMapEntry(Field field, Object value) {
+		return createMapEntry(field.getMappedKey(), value);
+	}
+
+	/**
+	 * Creates a new {@link Entry} with the given key and value.
+	 * 
+	 * @param key must not be {@literal null} or empty.
+	 * @param value can be {@literal null}
+	 * @return
+	 */
+	private Entry<String, Object> createMapEntry(String key, Object value) {
+
+		Assert.hasText(key, "Key must not be null or empty!");
+		return Collections.singletonMap(key, value).entrySet().iterator().next();
+	}
+
 	private DBRef createDbRefFor(Object source, MongoPersistentProperty property) {
 
 		if (source instanceof DBRef) {

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/convert/UpdateMapper.java

@@ -16,7 +16,6 @@
 package org.springframework.data.mongodb.core.convert;
 
 import java.util.Arrays;
-import java.util.Collections;
 import java.util.Iterator;
 import java.util.Map.Entry;
 
@@ -76,6 +75,10 @@ public class UpdateMapper extends QueryMapper {
 	@Override
 	protected Entry<String, Object> getMappedObjectForField(Field field, Object rawValue) {
 
+		if (isDBObject(rawValue)) {
+			return createMapEntry(field, convertSimpleOrDBObject(rawValue, field.getPropertyEntity()));
+		}
+
 		if (!isUpdateModifier(rawValue)) {
 			return super.getMappedObjectForField(field, getMappedValue(field, rawValue));
 		}
@@ -100,7 +103,7 @@ public class UpdateMapper extends QueryMapper {
 			throw new IllegalArgumentException(String.format("Unable to map value of type '%s'!", rawValue.getClass()));
 		}
 
-		return Collections.singletonMap(field.getMappedKey(), value).entrySet().iterator().next();
+		return createMapEntry(field, value);
 	}
 
 	/*
@@ -163,6 +166,15 @@ public class UpdateMapper extends QueryMapper {
 			this.key = key;
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.convert.QueryMapper.MetadataBackedField#getMappedKey()
+		 */
+		@Override
+		public String getMappedKey() {
+			return this.getPath() == null ? key : super.getMappedKey();
+		}
+
 		/* 
 		 * (non-Javadoc)
 		 * @see org.springframework.data.mongodb.core.convert.QueryMapper.MetadataBackedField#getPropertyConverter()

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/query/NearQuery.java

@@ -31,6 +31,7 @@ import com.mongodb.DBObject;
  * 
  * @author Oliver Gierke
  * @author Thomas Darimont
+ * @author Christoph Strobl
  */
 public final class NearQuery {
 
@@ -143,10 +144,12 @@ public final class NearQuery {
 	/**
 	 * Configures the {@link Pageable} to use.
 	 * 
-	 * @param pageable
+	 * @param pageable must not be {@literal null}
 	 * @return
 	 */
 	public NearQuery with(Pageable pageable) {
+
+		Assert.notNull(pageable, "Pageable must not be 'null'.");
 		this.num = pageable.getOffset() + pageable.getPageSize();
 		this.skip = pageable.getOffset();
 		return this;
@@ -311,13 +314,18 @@ public final class NearQuery {
 	/**
 	 * Adds an actual query to the {@link NearQuery} to restrict the objects considered for the actual near operation.
 	 * 
-	 * @param query
+	 * @param query must not be {@literal null}.
 	 * @return
 	 */
 	public NearQuery query(Query query) {
+
+		Assert.notNull(query, "Cannot apply 'null' query on NearQuery.");
 		this.query = query;
 		this.skip = query.getSkip();
-		this.num = query.getLimit();
+
+		if (query.getLimit() != 0) {
+			this.num = query.getLimit();
+		}
 		return this;
 	}
 

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/AbstractMongoQuery.java

@@ -79,22 +79,24 @@ public abstract class AbstractMongoQuery implements RepositoryQuery {
 		MongoParameterAccessor accessor = new MongoParametersParameterAccessor(method, parameters);
 		Query query = createQuery(new ConvertingParameterAccessor(operations.getConverter(), accessor));
 
+		Object result = null;
+
 		if (method.isGeoNearQuery() && method.isPageQuery()) {
 
 			MongoParameterAccessor countAccessor = new MongoParametersParameterAccessor(method, parameters);
 			Query countQuery = createCountQuery(new ConvertingParameterAccessor(operations.getConverter(), countAccessor));
 
-			return new GeoNearExecution(accessor).execute(query, countQuery);
+			result = new GeoNearExecution(accessor).execute(query, countQuery);
 		} else if (method.isGeoNearQuery()) {
 			return new GeoNearExecution(accessor).execute(query);
 		} else if (method.isCollectionQuery()) {
-			return new CollectionExecution(accessor.getPageable()).execute(query);
+			result = new CollectionExecution(accessor.getPageable()).execute(query);
 		} else if (method.isPageQuery()) {
-			return new PagedExecution(accessor.getPageable()).execute(query);
+			result = new PagedExecution(accessor.getPageable()).execute(query);
+		} else {
+			result = new SingleEntityExecution(isCountQuery()).execute(query);
 		}
 
-		Object result = new SingleEntityExecution(isCountQuery()).execute(query);
-
 		if (result == null) {
 			return result;
 		}

spring-data-mongodb/src/test/java/ConfigClassInDefaultPackage.java

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2014 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.mongodb.config.AbstractMongoConfiguration;
+
+import com.mongodb.Mongo;
+import com.mongodb.MongoClient;
+
+/**
+ * Sample configuration class in default package.
+ * 
+ * @see DATAMONGO-877
+ * @author Oliver Gierke
+ */
+@Configuration
+public class ConfigClassInDefaultPackage extends AbstractMongoConfiguration {
+
+	/* 
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.config.AbstractMongoConfiguration#getDatabaseName()
+	 */
+	@Override
+	protected String getDatabaseName() {
+		return "default";
+	}
+
+	/* 
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.config.AbstractMongoConfiguration#mongo()
+	 */
+	@Override
+	public Mongo mongo() throws Exception {
+		return new MongoClient();
+	}
+}

spring-data-mongodb/src/test/java/ConfigClassInDefaultPackageUnitTests.java

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2014 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import org.junit.Test;
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+
+/**
+ * Unit test for {@link ConfigClassInDefaultPackage}.
+ * 
+ * @see DATAMONGO-877
+ * @author Oliver Gierke
+ */
+public class ConfigClassInDefaultPackageUnitTests {
+
+	/**
+	 * @see DATAMONGO-877
+	 */
+	@Test
+	public void loadsConfigClassFromDefaultPackage() {
+		new AnnotationConfigApplicationContext(ConfigClassInDefaultPackage.class).close();
+	}
+}

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/AuditingViaJavaConfigRepositoriesTests.java

@@ -23,6 +23,7 @@ import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.data.domain.AuditorAware;
@@ -96,6 +97,21 @@ public class AuditingViaJavaConfigRepositoriesTests {
 		assertThat(createdBy.getFirstname(), is(this.auditor.getFirstname()));
 	}
 
+	/**
+	 * @see DATAMONGO-843
+	 */
+	@Test
+	@SuppressWarnings("resource")
+	public void defaultsMappingContextIfNoneConfigured() {
+		new AnnotationConfigApplicationContext(SampleConfig.class);
+	}
+
 	@Repository
 	static interface AuditablePersonRepository extends MongoRepository<AuditablePerson, String> {}
+
+	@Configuration
+	@EnableMongoAuditing
+	static class SampleConfig {
+
+	}
 }

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/MongoTemplateTests.java

@@ -2293,8 +2293,6 @@ public class MongoTemplateTests {
 	}
 
 	/**
-	 * <<<<<<< HEAD
-	 * 
 	 * @see DATAMONOGO-828
 	 */
 	@Test
@@ -2394,7 +2392,7 @@ public class MongoTemplateTests {
 		assertThat(result.dbRefAnnotatedList.get(0), is(notNullValue()));
 		assertThat(result.dbRefAnnotatedList.get(0).id, is((Object) "1"));
 	}
-	
+
 	/**
 	 * @see DATAMONGO-852
 	 */
@@ -2422,7 +2420,7 @@ public class MongoTemplateTests {
 	 * @see DATAMONGO-468
 	 */
 	@Test
-	public void shouldBeAbleToUpdateDbRefPropertyWithDomainObject(){
+	public void shouldBeAbleToUpdateDbRefPropertyWithDomainObject() {
 
 		Sample sample1 = new Sample("1", "A");
 		Sample sample2 = new Sample("2", "B");
@@ -2434,17 +2432,63 @@ public class MongoTemplateTests {
 		doc.dbRefProperty = sample1;
 		template.save(doc);
 
-		Update update = new Update().set("dbRefProperty",sample2);
+		Update update = new Update().set("dbRefProperty", sample2);
 
 		Query qry = query(where("id").is("1"));
 		template.updateFirst(qry, update, DocumentWithDBRefCollection.class);
 
 		DocumentWithDBRefCollection updatedDoc = template.findOne(qry, DocumentWithDBRefCollection.class);
 
-		assertThat(updatedDoc,is(notNullValue()));
-		assertThat(updatedDoc.dbRefProperty,is(notNullValue()));
-		assertThat(updatedDoc.dbRefProperty.id,is(sample2.id));
-		assertThat(updatedDoc.dbRefProperty.field,is(sample2.field));
+		assertThat(updatedDoc, is(notNullValue()));
+		assertThat(updatedDoc.dbRefProperty, is(notNullValue()));
+		assertThat(updatedDoc.dbRefProperty.id, is(sample2.id));
+		assertThat(updatedDoc.dbRefProperty.field, is(sample2.field));
+	}
+
+	/**
+	 * @see DATAMONGO-862
+	 */
+	@Test
+	public void testUpdateShouldWorkForPathsOnInterfaceMethods() {
+
+		DocumentWithCollection document = new DocumentWithCollection(Arrays.<Model> asList(new ModelA("spring"),
+				new ModelA("data")));
+
+		template.save(document);
+
+		Query query = query(where("id").is(document.id).and("models._id").exists(true));
+		Update update = new Update().set("models.$.value", "mongodb");
+		template.findAndModify(query, update, DocumentWithCollection.class);
+
+		DocumentWithCollection result = template.findOne(query(where("id").is(document.id)), DocumentWithCollection.class);
+		assertThat(result.models.get(0).value(), is("mongodb"));
+	}
+
+	/**
+	 * @see DATAMONGO-773
+	 */
+	@Test
+	public void testShouldSupportQueryWithIncludedDbRefField() {
+
+		Sample sample = new Sample("47111", "foo");
+		template.save(sample);
+
+		DocumentWithDBRefCollection doc = new DocumentWithDBRefCollection();
+		doc.id = "4711";
+		doc.dbRefProperty = sample;
+
+		template.save(doc);
+
+		Query qry = query(where("id").is(doc.id));
+		qry.fields().include("dbRefProperty");
+
+		List<DocumentWithDBRefCollection> result = template.find(qry, DocumentWithDBRefCollection.class);
+
+		assertThat(result, is(notNullValue()));
+		assertThat(result, hasSize(1));
+		assertThat(result.get(0), is(notNullValue()));
+		assertThat(result.get(0).dbRefProperty, is(notNullValue()));
+		assertThat(result.get(0).dbRefProperty.field, is(sample.field));
 	}
 
 	static class DocumentWithDBRefCollection {
@@ -2454,7 +2498,7 @@ public class MongoTemplateTests {
 		@org.springframework.data.mongodb.core.mapping.DBRef//
 		public List<Sample> dbRefAnnotatedList;
 
-		@org.springframework.data.mongodb.core.mapping.DBRef
+		@org.springframework.data.mongodb.core.mapping.DBRef//
 		public Sample dbRefProperty;
 	}
 
@@ -2482,10 +2526,13 @@ public class MongoTemplateTests {
 
 	static interface Model {
 		String value();
+
+		String id();
 	}
 
 	static class ModelA implements Model {
 
+		@Id String id;
 		private String value;
 
 		ModelA(String value) {
@@ -2496,6 +2543,11 @@ public class MongoTemplateTests {
 		public String value() {
 			return this.value;
 		}
+
+		@Override
+		public String id() {
+			return id;
+		}
 	}
 
 	static class Document {

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/MongoTemplateUnitTests.java

@@ -25,10 +25,14 @@ import java.util.Collections;
 import java.util.regex.Pattern;
 
 import org.bson.types.ObjectId;
+import org.hamcrest.core.Is;
+import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
 import org.mockito.ArgumentMatcher;
+import org.mockito.Matchers;
 import org.mockito.Mock;
 import org.mockito.Mockito;
 import org.mockito.runners.MockitoJUnitRunner;
@@ -37,6 +41,7 @@ import org.springframework.core.convert.converter.Converter;
 import org.springframework.dao.DataAccessException;
 import org.springframework.dao.InvalidDataAccessApiUsageException;
 import org.springframework.data.annotation.Id;
+import org.springframework.data.annotation.Version;
 import org.springframework.data.mongodb.MongoDbFactory;
 import org.springframework.data.mongodb.core.convert.CustomConversions;
 import org.springframework.data.mongodb.core.convert.DefaultDbRefResolver;
@@ -48,6 +53,7 @@ import org.springframework.data.mongodb.core.query.Query;
 import org.springframework.data.mongodb.core.query.Update;
 import org.springframework.test.util.ReflectionTestUtils;
 
+import com.mongodb.BasicDBObject;
 import com.mongodb.DB;
 import com.mongodb.DBCollection;
 import com.mongodb.DBObject;
@@ -58,6 +64,7 @@ import com.mongodb.MongoException;
  * Unit tests for {@link MongoTemplate}.
  * 
  * @author Oliver Gierke
+ * @author Christoph Strobl
  */
 @RunWith(MockitoJUnitRunner.class)
 public class MongoTemplateUnitTests extends MongoOperationsUnitTests {
@@ -205,6 +212,46 @@ public class MongoTemplateUnitTests extends MongoOperationsUnitTests {
 		assertThat(entity.id, is(5));
 	}
 
+	/**
+	 * @see DATAMONGO-868
+	 */
+	@Test
+	public void findAndModifyShouldBumpVersionByOneWhenVersionFieldNotIncludedInUpdate() {
+
+		VersionedEntity v = new VersionedEntity();
+		v.id = 1;
+		v.version = 0;
+
+		ArgumentCaptor<DBObject> captor = ArgumentCaptor.forClass(DBObject.class);
+
+		template.findAndModify(new Query(), new Update().set("id", "10"), VersionedEntity.class);
+		verify(collection, times(1)).findAndModify(Matchers.any(DBObject.class),
+				org.mockito.Matchers.isNull(DBObject.class), org.mockito.Matchers.isNull(DBObject.class), eq(false),
+				captor.capture(), eq(false), eq(false));
+
+		Assert.assertThat(captor.getValue().get("$inc"), Is.<Object> is(new BasicDBObject("version", 1)));
+	}
+
+	/**
+	 * @see DATAMONGO-868
+	 */
+	@Test
+	public void findAndModifyShouldNotBumpVersionByOneWhenVersionFieldAlreadyIncludedInUpdate() {
+
+		VersionedEntity v = new VersionedEntity();
+		v.id = 1;
+		v.version = 0;
+
+		ArgumentCaptor<DBObject> captor = ArgumentCaptor.forClass(DBObject.class);
+
+		template.findAndModify(new Query(), new Update().set("version", 100), VersionedEntity.class);
+		verify(collection, times(1)).findAndModify(Matchers.any(DBObject.class), isNull(DBObject.class),
+				isNull(DBObject.class), eq(false), captor.capture(), eq(false), eq(false));
+
+		Assert.assertThat(captor.getValue().get("$set"), Is.<Object> is(new BasicDBObject("version", 100)));
+		Assert.assertThat(captor.getValue().get("$inc"), nullValue());
+	}
+
 	/**
 	 * @see DATAMONGO-533
 	 */
@@ -249,6 +296,12 @@ public class MongoTemplateUnitTests extends MongoOperationsUnitTests {
 		}
 	}
 
+	static class VersionedEntity {
+
+		@Id Integer id;
+		@Version Integer version;
+	}
+
 	enum MyConverter implements Converter<AutogenerateableId, String> {
 
 		INSTANCE;

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/MappingMongoConverterUnitTests.java

@@ -28,6 +28,8 @@ import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Date;
+import java.util.EnumMap;
+import java.util.EnumSet;
 import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.List;
@@ -1454,6 +1456,37 @@ public class MappingMongoConverterUnitTests {
 		assertThat(dbList.get(0), instanceOf(String.class));
 	}
 
+	/**
+	 * @see DATAMONGO-833
+	 */
+	@Test
+	public void readsEnumSetCorrectly() {
+
+		BasicDBList enumSet = new BasicDBList();
+		enumSet.add("SECOND");
+		DBObject dbObject = new BasicDBObject("enumSet", enumSet);
+
+		ClassWithEnumProperty result = converter.read(ClassWithEnumProperty.class, dbObject);
+
+		assertThat(result.enumSet, is(instanceOf(EnumSet.class)));
+		assertThat(result.enumSet.size(), is(1));
+		assertThat(result.enumSet, hasItem(SampleEnum.SECOND));
+	}
+
+	/**
+	 * @see DATAMONGO-833
+	 */
+	@Test
+	public void readsEnumMapCorrectly() {
+
+		BasicDBObject enumMap = new BasicDBObject("FIRST", "Dave");
+		ClassWithEnumProperty result = converter.read(ClassWithEnumProperty.class, new BasicDBObject("enumMap", enumMap));
+
+		assertThat(result.enumMap, is(instanceOf(EnumMap.class)));
+		assertThat(result.enumMap.size(), is(1));
+		assertThat(result.enumMap.get(SampleEnum.FIRST), is("Dave"));
+	}
+
 	static class GenericType<T> {
 		T content;
 	}
@@ -1462,6 +1495,8 @@ public class MappingMongoConverterUnitTests {
 
 		SampleEnum sampleEnum;
 		List<SampleEnum> enums;
+		EnumSet<SampleEnum> enumSet;
+		EnumMap<SampleEnum, String> enumMap;
 	}
 
 	static enum SampleEnum {

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/QueryMapperUnitTests.java

@@ -57,6 +57,7 @@ import com.mongodb.QueryBuilder;
  * @author Oliver Gierke
  * @author Patryk Wasik
  * @author Thomas Darimont
+ * @author Christoph Strobl
  */
 @RunWith(MockitoJUnitRunner.class)
 public class QueryMapperUnitTests {
@@ -501,6 +502,72 @@ public class QueryMapperUnitTests {
 		assertThat(idValuesAfter, is(idValuesBefore));
 	}
 
+	/**
+	 * @see DATAMONGO-821
+	 */
+	@Test
+	public void queryMapperShouldNotTryToMapDBRefListPropertyIfNestedInsideDBObjectWithinDBObject() {
+
+		DBObject queryObject = query(
+				where("referenceList").is(new BasicDBObject("$nested", new BasicDBObject("$keys", 0L)))).getQueryObject();
+
+		DBObject mappedObject = mapper.getMappedObject(queryObject, context.getPersistentEntity(WithDBRefList.class));
+		DBObject referenceObject = getAsDBObject(mappedObject, "referenceList");
+		DBObject nestedObject = getAsDBObject(referenceObject, "$nested");
+
+		assertThat(nestedObject, is((DBObject) new BasicDBObject("$keys", 0L)));
+	}
+
+	/**
+	 * @see DATAMONGO-821
+	 */
+	@Test
+	public void queryMapperShouldNotTryToMapDBRefPropertyIfNestedInsideDBObjectWithinDBObject() {
+
+		DBObject queryObject = query(where("reference").is(new BasicDBObject("$nested", new BasicDBObject("$keys", 0L))))
+				.getQueryObject();
+
+		DBObject mappedObject = mapper.getMappedObject(queryObject, context.getPersistentEntity(WithDBRef.class));
+		DBObject referenceObject = getAsDBObject(mappedObject, "reference");
+		DBObject nestedObject = getAsDBObject(referenceObject, "$nested");
+
+		assertThat(nestedObject, is((DBObject) new BasicDBObject("$keys", 0L)));
+	}
+
+	/**
+	 * @see DATAMONGO-821
+	 */
+	@Test
+	public void queryMapperShouldMapDBRefPropertyIfNestedInDBObject() {
+
+		Reference sample = new Reference();
+		sample.id = 321L;
+		DBObject queryObject = query(where("reference").is(new BasicDBObject("$in", Arrays.asList(sample))))
+				.getQueryObject();
+
+		DBObject mappedObject = mapper.getMappedObject(queryObject, context.getPersistentEntity(WithDBRef.class));
+
+		DBObject referenceObject = getAsDBObject(mappedObject, "reference");
+		BasicDBList inObject = getAsDBList(referenceObject, "$in");
+
+		assertThat(inObject.get(0), is(instanceOf(com.mongodb.DBRef.class)));
+	}
+
+	/**
+	 * @see DATAMONGO-773
+	 */
+	@Test
+	public void queryMapperShouldBeAbleToProcessQueriesThatIncludeDbRefFields() {
+
+		BasicMongoPersistentEntity<?> persistentEntity = context.getPersistentEntity(WithDBRef.class);
+
+		Query qry = query(where("someString").is("abc"));
+		qry.fields().include("reference");
+
+		DBObject mappedFields = mapper.getMappedObject(qry.getFieldsObject(), persistentEntity);
+		assertThat(mappedFields, is(notNullValue()));
+	}
+
 	class IdWrapper {
 		Object id;
 	}
@@ -541,6 +608,12 @@ public class QueryMapperUnitTests {
 		@DBRef Reference reference;
 	}
 
+	class WithDBRefList {
+
+		String someString;
+		@DBRef List<Reference> referenceList;
+	}
+
 	class Reference {
 
 		Long id;

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/UpdateMapperUnitTests.java

@@ -25,6 +25,7 @@ import java.util.Arrays;
 import java.util.List;
 
 import org.hamcrest.Matcher;
+import org.hamcrest.collection.IsIterableContainingInOrder;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -376,6 +377,41 @@ public class UpdateMapperUnitTests {
 		assertThat(setClause.get("dbRefProperty"), is((Object) new DBRef(null, "entity", entity.id)));
 	}
 
+	/**
+	 * @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-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));
+	}
+
 	static interface Model {}
 
 	static class ModelImpl implements Model {
@@ -384,6 +420,7 @@ public class UpdateMapperUnitTests {
 		public ModelImpl(int value) {
 			this.value = value;
 		}
+
 	}
 
 	public class ModelWrapper {
@@ -411,6 +448,9 @@ public class UpdateMapperUnitTests {
 		@Field("aliased")//
 		List<? extends AbstractChildClass> list;
 
+		@Field//
+		List<Model> listOfInterface;
+
 		public ParentClass(String id, List<? extends AbstractChildClass> list) {
 			this.id = id;
 			this.list = list;

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/NearQueryUnitTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2013 the original author or authors.
+ * Copyright 2011-2014 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,6 +21,7 @@ import static org.junit.Assert.*;
 import org.junit.Test;
 import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Pageable;
+import org.springframework.data.mongodb.core.DBObjectTestUtils;
 import org.springframework.data.mongodb.core.geo.Distance;
 import org.springframework.data.mongodb.core.geo.Metric;
 import org.springframework.data.mongodb.core.geo.Metrics;
@@ -31,6 +32,7 @@ import org.springframework.data.mongodb.core.geo.Point;
  * 
  * @author Oliver Gierke
  * @author Thomas Darimont
+ * @author Christoph Strobl
  */
 public class NearQueryUnitTests {
 
@@ -123,4 +125,36 @@ public class NearQueryUnitTests {
 		assertThat(query.getSkip(), is(pageable.getPageNumber() * pageable.getPageSize()));
 		assertThat((Integer) query.toDBObject().get("num"), is((pageable.getPageNumber() + 1) * pageable.getPageSize()));
 	}
+
+	/**
+	 * @see DATAMONGO-829
+	 */
+	@Test
+	public void nearQueryShouldInoreZeroLimitFromQuery() {
+
+		NearQuery query = NearQuery.near(new Point(1, 2)).query(Query.query(Criteria.where("foo").is("bar")));
+		assertThat(query.toDBObject().get("num"), nullValue());
+	}
+
+	/**
+	 * @see DATAMONOGO-829
+	 */
+	@Test(expected = IllegalArgumentException.class)
+	public void nearQueryShouldThrowExceptionWhenGivenANullQuery() {
+		NearQuery.near(new Point(1, 2)).query(null);
+	}
+
+	/**
+	 * @see DATAMONGO-829
+	 */
+	@Test
+	public void numShouldNotBeAlteredByQueryWithoutPageable() {
+
+		int num = 100;
+		NearQuery query = NearQuery.near(new Point(1, 2));
+		query.num(num);
+		query.query(Query.query(Criteria.where("foo").is("bar")));
+
+		assertThat(DBObjectTestUtils.getTypedValue(query.toDBObject(), "num", Integer.class), is(num));
+	}
 }

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/AbstractPersonRepositoryIntegrationTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2013 the original author or authors.
+ * Copyright 2011-2014 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -50,6 +50,7 @@ import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  * 
  * @author Oliver Gierke
  * @author Thomas Darimont
+ * @author Christoph Strobl
  */
 @RunWith(SpringJUnit4ClassRunner.class)
 public abstract class AbstractPersonRepositoryIntegrationTests {
@@ -738,4 +739,37 @@ public abstract class AbstractPersonRepositoryIntegrationTests {
 		assertThat(result.size(), is(1));
 		assertThat(result.get(0), is(dave));
 	}
+	
+	/**
+	 * @see DATAMONGO-871
+	 */
+	@Test
+	public void findsPersonsByFirstnameAsArray() {
+
+		Person[] result = repository.findByThePersonsFirstnameAsArray("Leroi");
+
+		assertThat(result, is(arrayWithSize(1)));
+		assertThat(result, is(arrayContaining(leroi)));
+	}
+	
+	
+	/**
+	 * @see DATAMONGO-821
+	 */
+	@Test
+	public void findUsingAnnotatedQueryOnDBRef() {
+
+		operations.remove(new org.springframework.data.mongodb.core.query.Query(), User.class);
+
+		User user = new User();
+		user.username = "Terria";
+		operations.save(user);
+
+		alicia.creator = user;
+		repository.save(alicia);
+
+		Page<Person> result = repository.findByHavingCreator(new PageRequest(0, 100));
+		assertThat(result.getNumberOfElements(), is(1));
+		assertThat(result.getContent().get(0), is(alicia));
+	}
 }

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/PersonRepository.java

@@ -37,6 +37,7 @@ import org.springframework.data.querydsl.QueryDslPredicateExecutor;
  * 
  * @author Oliver Gierke
  * @author Thomas Darimont
+ * @author Christoph Strobl
  */
 public interface PersonRepository extends MongoRepository<Person, String>, QueryDslPredicateExecutor<Person> {
 
@@ -70,6 +71,12 @@ public interface PersonRepository extends MongoRepository<Person, String>, Query
 	@Query(value = "{ 'firstname' : ?0 }", fields = "{ 'firstname': 1, 'lastname': 1}")
 	List<Person> findByThePersonsFirstname(String firstname);
 
+	/**
+	 * @see DATAMONGO-871
+	 */
+	@Query(value = "{ 'firstname' : ?0 }")
+	Person[] findByThePersonsFirstnameAsArray(String firstname);
+
 	/**
 	 * Returns all {@link Person}s with a firstname matching the given one (*-wildcard supported).
 	 * 
@@ -244,5 +251,10 @@ public interface PersonRepository extends MongoRepository<Person, String>, Query
 	 * @see DATAMONGO-770
 	 */
 	List<Person> findByFirstnameContainingIgnoreCase(String firstName);
-
+	
+	/**
+	 * @see DATAMONGO-821
+	 */
+	@Query("{ creator : { $exists : true } }")
+	Page<Person> findByHavingCreator(Pageable page);
 }

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/query/StringBasedMongoQueryUnitTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2013 the original author or authors.
+ * Copyright 2011-2014 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -45,6 +45,7 @@ import com.mongodb.DBObject;
  * Unit tests for {@link StringBasedMongoQuery}.
  * 
  * @author Oliver Gierke
+ * @author Christoph Strobl
  */
 @RunWith(MockitoJUnitRunner.class)
 public class StringBasedMongoQueryUnitTests {
@@ -126,6 +127,19 @@ public class StringBasedMongoQueryUnitTests {
 		assertThat(query.getQueryObject().get("address"), is(nullValue()));
 	}
 
+	/**
+	 * @see DATAMONGO-821
+	 */
+	@Test
+	public void bindsDbrefCorrectly() throws Exception {
+
+		StringBasedMongoQuery mongoQuery = createQueryForMethod("findByHavingSizeFansNotZero");
+		ConvertingParameterAccessor accessor = StubParameterAccessor.getAccessor(converter, new Object[] {});
+
+		org.springframework.data.mongodb.core.query.Query query = mongoQuery.createQuery(accessor);
+		assertThat(query.getQueryObject(), is(new BasicQuery("{ fans : { $not : { $size : 0 } } }").getQueryObject()));
+	}
+
 	private StringBasedMongoQuery createQueryForMethod(String name, Class<?>... parameters) throws Exception {
 
 		Method method = SampleRepository.class.getMethod(name, parameters);
@@ -143,5 +157,9 @@ public class StringBasedMongoQueryUnitTests {
 
 		@Query("{ 'lastname' : ?0, 'address' : ?1 }")
 		Person findByLastnameAndAddress(String lastname, Address address);
+
+		@Query("{ fans : { $not : { $size : 0 } } }")
+		Person findByHavingSizeFansNotZero();
+
 	}
 }

src/docbkx/index.xml

@@ -68,7 +68,7 @@
     <xi:include href="introduction/introduction.xml"/>
     <xi:include href="introduction/requirements.xml"/>
     <xi:include href="introduction/getting-started.xml"/>
-    <xi:include href="https://raw.github.com/spring-projects/spring-data-commons/1.7.0.RELEASE/src/docbkx/repositories.xml">
+    <xi:include href="https://raw.github.com/spring-projects/spring-data-commons/1.7.1.RELEASE/src/docbkx/repositories.xml">
       <xi:fallback href="../../../spring-data-commons/src/docbkx/repositories.xml" />
     </xi:include>
   </part>
@@ -88,10 +88,10 @@
   <part id="appendix">
     <title>Appendix</title>
 
-    <xi:include href="https://raw.github.com/spring-projects/spring-data-commons/1.7.0.RELEASE/src/docbkx/repository-namespace-reference.xml">
+    <xi:include href="https://raw.github.com/spring-projects/spring-data-commons/1.7.1.RELEASE/src/docbkx/repository-namespace-reference.xml">
     	<xi:fallback href="../../../spring-data-commons/src/docbkx/repository-namespace-reference.xml" />
     </xi:include>
-    <xi:include href="https://raw.github.com/spring-projects/spring-data-commons/1.7.0.RELEASE/src/docbkx/repository-query-keywords-reference.xml">
+    <xi:include href="https://raw.github.com/spring-projects/spring-data-commons/1.7.1.RELEASE/src/docbkx/repository-query-keywords-reference.xml">
     	<xi:fallback href="../../../spring-data-commons/src/docbkx/repository-query-keywords-reference.xml" />
     </xi:include>
   </part>

src/docbkx/reference/mongodb.xml

@@ -107,7 +107,7 @@
   <dependency>
     <groupId>org.springframework.data</groupId>
     <artifactId>spring-data-mongodb</artifactId>
-    <version>1.3.4.RELEASE</version>
+    <version>1.4.1.RELEASE</version>
   </dependency>
 
 &lt;/dependencies&gt;</programlisting>

src/main/resources/changelog.txt

@@ -1,9 +1,35 @@
 Spring Data MongoDB Changelog
 =============================
 
+Changes in version 1.4.1.RELEASE (2014-03-13)
+---------------------------------------------
+** Fix
+    * [DATAMONGO-773] - Verify that @DBRef fields can be included in query.
+    * [DATAMONGO-821] - Fixed handling of keyword expressions for DBRefs.
+    * [DATAMONGO-829] - NearQuery should not default 'num' to zero.
+    * [DATAMONGO-833] - Support for EnumSet and EnumMap in MappingMongoConverter.
+    * [DATAMONGO-843] - Back-port of defaulting of the MappingContext for auditing.
+    * [DATAMONGO-862] - Fixed handling of unmapped paths for updates.
+    * [DATAMONGO-863] - UpdateMapper doesn't convert raw DBObjects anymore.
+    * [DATAMONGO-868] - MongoTemplate.findAndModify(…) increases version if not handled manually.
+    * [DATAMONGO-871] - Add support for arrays as query method return types.
+    * [DATAMONGO-877] - Added guard against null-package in AbstractMappingConfiguration.
+
+** Improvement
+    * [DATAMONGO-865] - Adjust test dependencies to avoid ClassNotFoundException during test runs.
+
+Changes in version 1.3.5.RELEASE (2014-03-10)
+---------------------------------------------
+** Fix
+    * [DATAMONGO-829] - NearQuery, when used in conjunction with a Query, no longer sets num=0, unless Query specifies otherwise.
+    * [DATAMONGO-871] - Repository queries support array return type.
+
+** Improvement
+    * [DATAMONGO-865] - Avoid ClassNotFoundException during test runs.
+
+
 Changes in version 1.4.0.RELEASE (2014-02-24)
 ---------------------------------------------
-
 ** Fix
     * [DATAMONGO-354] - MongoTemplate should support multiple $pushAll in one update.
     * [DATAMONGO-404] - Removing a DBRef using pull does not work.
@@ -23,7 +49,7 @@ Changes in version 1.4.0.RELEASE (2014-02-24)
     * [DATAMONGO-848] - Ensure compatibility with Mongo Java driver 2.12.
     * [DATAMONGO-853] - Update no longer allows null keys.
     * [DATAMONGO-856] - Update documentation.
-    
+
 Changes in version 1.3.4.RELEASE (2014-02-17)
 ---------------------------------------------
 ** Bug

src/main/resources/notice.txt

@@ -1,4 +1,4 @@
-Spring Data MongoDB 1.4.0.RELEASE
+Spring Data MongoDB 1.4.1.RELEASE
 Copyright (c) [2010-2014] Pivotal Software, Inc.
 
 This product is licensed to you under the Apache License, Version 2.0 (the "License").  

src/main/resources/readme.txt

@@ -1,4 +1,4 @@
-SPRING DATA MongoDB 1.4.0.RELEASE
+SPRING DATA MongoDB 1.4.1.RELEASE
 ---------------------------------
 
 Spring Data MongoDB is released under the terms of the Apache Software License Version 2.0 (see license.txt).