DATAMONGO-971 - Release version 1.5.1.RELEASE (Dijkstra SR1).

We now check on intersections of given path and existing to not only check types and contained property names but also properties full path which must not be present in already traversed paths.

Additionally we’ll now catch any CyclicPropertyReferenceExceptions on the root level to prevent cycle detection interfering with application startup.

Original pull request: #197.

pom.xml

@@ -5,7 +5,7 @@
 	
 	<groupId>org.springframework.data</groupId>
 	<artifactId>spring-data-mongodb-parent</artifactId>
-	<version>1.5.0.RELEASE</version>
+	<version>1.5.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.4.0.RELEASE</version>
+		<version>1.4.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.8.0.RELEASE</springdata.commons>
+		<springdata.commons>1.8.1.RELEASE</springdata.commons>
 		<mongo>2.12.1</mongo>
 	</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.5.0.RELEASE</version>
+		<version>1.5.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.5.0.RELEASE</version>
+			<version>1.5.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.5.0.RELEASE</version>
+		<version>1.5.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.5.0.RELEASE</version>
+		<version>1.5.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.5.0.RELEASE</version>
+		<version>1.5.1.RELEASE</version>
 		<relativePath>../pom.xml</relativePath>
 	</parent>
 

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

@@ -1070,17 +1070,22 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	}
 
 	/**
-	 * Returns {@link Entry} containing the {@link MongoPersistentProperty} defining the {@literal id} as
-	 * {@link Entry#getKey()} and the {@link Id}s property value as its {@link Entry#getValue()}.
+	 * Returns {@link Entry} containing the field name of the id property as {@link Entry#getKey()} and the {@link Id}s
+	 * property value as its {@link Entry#getValue()}.
 	 * 
 	 * @param object
 	 * @return
 	 */
-	private Map.Entry<MongoPersistentProperty, Object> extractIdPropertyAndValue(Object object) {
+	private Entry<String, Object> extractIdPropertyAndValue(Object object) {
 
 		Assert.notNull(object, "Id cannot be extracted from 'null'.");
 
 		Class<?> objectType = object.getClass();
+
+		if (object instanceof DBObject) {
+			return Collections.singletonMap(ID_FIELD, ((DBObject) object).get(ID_FIELD)).entrySet().iterator().next();
+		}
+
 		MongoPersistentEntity<?> entity = mappingContext.getPersistentEntity(objectType);
 		MongoPersistentProperty idProp = entity == null ? null : entity.getIdProperty();
 
@@ -1090,7 +1095,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 
 		Object idValue = BeanWrapper.create(object, mongoConverter.getConversionService())
 				.getProperty(idProp, Object.class);
-		return Collections.singletonMap(idProp, idValue).entrySet().iterator().next();
+		return Collections.singletonMap(idProp.getFieldName(), idValue).entrySet().iterator().next();
 	}
 
 	/**
@@ -1101,8 +1106,8 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	 */
 	private Query getIdQueryFor(Object object) {
 
-		Map.Entry<MongoPersistentProperty, Object> id = extractIdPropertyAndValue(object);
-		return new Query(where(id.getKey().getFieldName()).is(id.getValue()));
+		Entry<String, Object> id = extractIdPropertyAndValue(object);
+		return new Query(where(id.getKey()).is(id.getValue()));
 	}
 
 	/**
@@ -1116,7 +1121,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 		Assert.notEmpty(objects, "Cannot create Query for empty collection.");
 
 		Iterator<?> it = objects.iterator();
-		Map.Entry<MongoPersistentProperty, Object> firstEntry = extractIdPropertyAndValue(it.next());
+		Entry<String, Object> firstEntry = extractIdPropertyAndValue(it.next());
 
 		ArrayList<Object> ids = new ArrayList<Object>(objects.size());
 		ids.add(firstEntry.getValue());
@@ -1125,7 +1130,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 			ids.add(extractIdPropertyAndValue(it.next()).getValue());
 		}
 
-		return new Query(where(firstEntry.getKey().getFieldName()).in(ids));
+		return new Query(where(firstEntry.getKey()).in(ids));
 	}
 
 	private void assertUpdateableIdIfNotSet(Object entity) {
@@ -1455,13 +1460,13 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 						"Can not use skip or field specification with map reduce operations");
 			}
 			if (query.getQueryObject() != null) {
-				copyMapReduceOptions.put("query", query.getQueryObject());
+				copyMapReduceOptions.put("query", queryMapper.getMappedObject(query.getQueryObject(), null));
 			}
 			if (query.getLimit() > 0) {
 				copyMapReduceOptions.put("limit", query.getLimit());
 			}
 			if (query.getSortObject() != null) {
-				copyMapReduceOptions.put("sort", query.getSortObject());
+				copyMapReduceOptions.put("sort", queryMapper.getMappedObject(query.getSortObject(), null));
 			}
 		}
 		return copyMapReduceOptions;
@@ -2179,7 +2184,8 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 					cursorToUse = cursorToUse.limit(query.getLimit());
 				}
 				if (query.getSortObject() != null) {
-					cursorToUse = cursorToUse.sort(getMappedSortObject(query, type));
+					DBObject sortDbo = type != null ? getMappedSortObject(query, type) : query.getSortObject();
+					cursorToUse = cursorToUse.sort(sortDbo);
 				}
 				if (StringUtils.hasText(query.getHint())) {
 					cursorToUse = cursorToUse.hint(query.getHint());

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

@@ -107,8 +107,11 @@ public @interface CompoundIndex {
 	/**
 	 * Configures the number of seconds after which the collection should expire. Defaults to -1 for no expiry.
 	 * 
+	 * @deprecated TTL cannot be defined for {@link CompoundIndex} having more than one field as key. Will be removed in
+	 *             1.6.
 	 * @see http://docs.mongodb.org/manual/tutorial/expire-data/
 	 * @return
 	 */
+	@Deprecated
 	int expireAfterSeconds() default -1;
 }

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

@@ -21,8 +21,6 @@ import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.TimeUnit;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -103,15 +101,19 @@ public class MongoPersistentEntityIndexResolver implements IndexResolver {
 			@Override
 			public void doWithPersistentProperty(MongoPersistentProperty persistentProperty) {
 
-				if (persistentProperty.isEntity()) {
-					indexInformation.addAll(resolveIndexForClass(persistentProperty.getActualType(),
-							persistentProperty.getFieldName(), root.getCollection(), guard));
-				}
+				try {
+					if (persistentProperty.isEntity()) {
+						indexInformation.addAll(resolveIndexForClass(persistentProperty.getActualType(),
+								persistentProperty.getFieldName(), root.getCollection(), guard));
+					}
 
-				IndexDefinitionHolder indexDefinitionHolder = createIndexDefinitionHolderForProperty(
-						persistentProperty.getFieldName(), root.getCollection(), persistentProperty);
-				if (indexDefinitionHolder != null) {
-					indexInformation.add(indexDefinitionHolder);
+					IndexDefinitionHolder indexDefinitionHolder = createIndexDefinitionHolderForProperty(
+							persistentProperty.getFieldName(), root.getCollection(), persistentProperty);
+					if (indexDefinitionHolder != null) {
+						indexInformation.add(indexDefinitionHolder);
+					}
+				} catch (CyclicPropertyReferenceException e) {
+					LOGGER.warn(e.getMessage());
 				}
 			}
 		});
@@ -215,6 +217,7 @@ public class MongoPersistentEntityIndexResolver implements IndexResolver {
 		return indexDefinitions;
 	}
 
+	@SuppressWarnings("deprecation")
 	protected IndexDefinitionHolder createCompoundIndexDefinition(String dotPath, String fallbackCollection,
 			CompoundIndex index) {
 
@@ -237,8 +240,14 @@ public class MongoPersistentEntityIndexResolver implements IndexResolver {
 			indexDefinition.background();
 		}
 
-		if (index.expireAfterSeconds() >= 0) {
-			indexDefinition.expire(index.expireAfterSeconds(), TimeUnit.SECONDS);
+		int ttl = index.expireAfterSeconds();
+
+		if (ttl >= 0) {
+			if (indexDefinition.getIndexKeys().keySet().size() > 1) {
+				LOGGER.warn("TTL is not supported for compound index with more than one key. TTL={} will be ignored.", ttl);
+			} else {
+				indexDefinition.expire(ttl, TimeUnit.SECONDS);
+			}
 		}
 
 		String collection = StringUtils.hasText(index.collection()) ? index.collection() : fallbackCollection;
@@ -343,7 +352,7 @@ public class MongoPersistentEntityIndexResolver implements IndexResolver {
 	 * 
 	 * @author Christoph Strobl
 	 */
-	private static class CycleGuard {
+	static class CycleGuard {
 
 		private final Map<String, List<Path>> propertyTypeMap;
 
@@ -355,6 +364,7 @@ public class MongoPersistentEntityIndexResolver implements IndexResolver {
 		 * @param property The property to inspect
 		 * @param path The path under which the property can be reached.
 		 * @throws CyclicPropertyReferenceException in case a potential cycle is detected.
+		 * @see Path#cycles(MongoPersistentProperty, String)
 		 */
 		void protect(MongoPersistentProperty property, String path) throws CyclicPropertyReferenceException {
 
@@ -365,7 +375,7 @@ public class MongoPersistentEntityIndexResolver implements IndexResolver {
 
 				for (Path existingPath : paths) {
 
-					if (existingPath.cycles(property)) {
+					if (existingPath.cycles(property, path)) {
 						paths.add(new Path(property, path));
 						throw new CyclicPropertyReferenceException(property.getFieldName(), property.getOwner().getType(),
 								existingPath.getPath());
@@ -373,7 +383,6 @@ public class MongoPersistentEntityIndexResolver implements IndexResolver {
 				}
 
 				paths.add(new Path(property, path));
-
 			} else {
 
 				ArrayList<Path> paths = new ArrayList<Path>();
@@ -386,7 +395,30 @@ public class MongoPersistentEntityIndexResolver implements IndexResolver {
 			return property.getOwner().getType().getSimpleName() + ":" + property.getFieldName();
 		}
 
-		private static class Path {
+		/**
+		 * Path defines the property and its full path from the document root. <br />
+		 * A {@link Path} with {@literal spring.data.mongodb} would be created for the property {@code Three.mongodb}.
+		 * 
+		 * <pre>
+		 * <code>
+		 * &#64;Document
+		 * class One {
+		 *   Two spring;
+		 * }
+		 * 
+		 * class Two {
+		 *   Three data;
+		 * }
+		 * 
+		 * class Three {
+		 *   String mongodb;
+		 * }
+		 * </code>
+		 * </pre>
+		 * 
+		 * @author Christoph Strobl
+		 */
+		static class Path {
 
 			private final MongoPersistentProperty property;
 			private final String path;
@@ -401,17 +433,23 @@ public class MongoPersistentEntityIndexResolver implements IndexResolver {
 				return path;
 			}
 
-			boolean cycles(MongoPersistentProperty property) {
+			/**
+			 * Checks whether the given property is owned by the same entity and if it has been already visited by a subset of
+			 * the current path. Given {@literal foo.bar.bar} cycles if {@literal foo.bar} has already been visited and
+			 * {@code class Bar} contains a property of type {@code Bar}. The previously mentioned path would not cycle if
+			 * {@code class Bar} contained a property of type {@code SomeEntity} named {@literal bar}.
+			 * 
+			 * @param property
+			 * @param path
+			 * @return
+			 */
+			boolean cycles(MongoPersistentProperty property, String path) {
 
-				Pattern pattern = Pattern.compile("\\p{Punct}?" + Pattern.quote(property.getFieldName()) + "(\\p{Punct}|\\w)?");
-				Matcher matcher = pattern.matcher(path);
-
-				int count = 0;
-				while (matcher.find()) {
-					count++;
+				if (!property.getOwner().equals(this.property.getOwner())) {
+					return false;
 				}
 
-				return count >= 1 && property.getOwner().getType().equals(this.property.getOwner().getType());
+				return path.contains(this.path);
 			}
 		}
 	}
@@ -441,8 +479,8 @@ public class MongoPersistentEntityIndexResolver implements IndexResolver {
 		 */
 		@Override
 		public String getMessage() {
-			return String.format("Found cycle for field '%s' in type '%s' for path '%s'", propertyName, type.getSimpleName(),
-					dotPath);
+			return String.format("Found cycle for field '%s' in type '%s' for path '%s'", propertyName,
+					type != null ? type.getSimpleName() : "unknown", dotPath);
 		}
 	}
 

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

@@ -15,10 +15,11 @@
  */
 package org.springframework.data.mongodb.core.query;
 
+import static org.springframework.util.ObjectUtils.*;
+
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
-import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.List;
@@ -40,6 +41,7 @@ import com.mongodb.DBObject;
  * @author Oliver Gierke
  * @author Becca Gaspard
  * @author Christoph Strobl
+ * @author Thomas Darimont
  */
 public class Update {
 
@@ -279,6 +281,7 @@ public class Update {
 	}
 
 	public DBObject getUpdateObject() {
+
 		DBObject dbo = new BasicDBObject();
 		for (String k : modifierOps.keySet()) {
 			dbo.put(k, modifierOps.get(k));
@@ -335,14 +338,52 @@ public class Update {
 		return StringUtils.startsWithIgnoreCase(key, "$");
 	}
 
+	/* 
+	 * (non-Javadoc)
+	 * @see java.lang.Object#hashCode()
+	 */
+	@Override
+	public int hashCode() {
+		return getUpdateObject().hashCode();
+	}
+
+	/* 
+	 * (non-Javadoc)
+	 * @see java.lang.Object#equals(java.lang.Object)
+	 */
+	@Override
+	public boolean equals(Object obj) {
+
+		if (this == obj) {
+			return true;
+		}
+
+		if (obj == null || getClass() != obj.getClass()) {
+			return false;
+		}
+
+		Update that = (Update) obj;
+		return this.getUpdateObject().equals(that.getUpdateObject());
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see java.lang.Object#toString()
+	 */
+	@Override
+	public String toString() {
+		return getUpdateObject().toString();
+	}
+
 	/**
 	 * Modifiers holds a distinct collection of {@link Modifier}
 	 * 
 	 * @author Christoph Strobl
+	 * @author Thomas Darimont
 	 */
 	public static class Modifiers {
 
-		private HashMap<String, Modifier> modifiers;
+		private Map<String, Modifier> modifiers;
 
 		public Modifiers() {
 			this.modifiers = new LinkedHashMap<String, Modifier>(1);
@@ -355,6 +396,33 @@ public class Update {
 		public void addModifier(Modifier modifier) {
 			this.modifiers.put(modifier.getKey(), modifier);
 		}
+
+		/* (non-Javadoc)
+		 * @see java.lang.Object#hashCode()
+		 */
+		@Override
+		public int hashCode() {
+			return nullSafeHashCode(modifiers);
+		}
+
+		/* (non-Javadoc)
+		 * @see java.lang.Object#equals(java.lang.Object)
+		 */
+		@Override
+		public boolean equals(Object obj) {
+
+			if (this == obj) {
+				return true;
+			}
+
+			if (obj == null || getClass() != obj.getClass()) {
+				return false;
+			}
+
+			Modifiers that = (Modifiers) obj;
+
+			return this.modifiers.equals(that.modifiers);
+		}
 	}
 
 	/**
@@ -379,6 +447,7 @@ public class Update {
 	 * Implementation of {@link Modifier} representing {@code $each}.
 	 * 
 	 * @author Christoph Strobl
+	 * @author Thomas Darimont
 	 */
 	private static class Each implements Modifier {
 
@@ -399,6 +468,7 @@ public class Update {
 			}
 
 			Object[] convertedValues = new Object[values.length];
+
 			for (int i = 0; i < values.length; i++) {
 				convertedValues[i] = values[i];
 			}
@@ -406,21 +476,57 @@ public class Update {
 			return convertedValues;
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.query.Update.Modifier#getKey()
+		 */
 		@Override
 		public String getKey() {
 			return "$each";
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.query.Update.Modifier#getValue()
+		 */
 		@Override
 		public Object getValue() {
 			return this.values;
 		}
+
+		/* 
+		 * (non-Javadoc)
+		 * @see java.lang.Object#hashCode()
+		 */
+		@Override
+		public int hashCode() {
+			return nullSafeHashCode(values);
+		}
+
+		/* 
+		 * (non-Javadoc)
+		 * @see java.lang.Object#equals(java.lang.Object)
+		 */
+		@Override
+		public boolean equals(Object that) {
+
+			if (this == that) {
+				return true;
+			}
+
+			if (that == null || getClass() != that.getClass()) {
+				return false;
+			}
+
+			return nullSafeEquals(values, ((Each) that).values);
+		}
 	}
 
 	/**
 	 * Builder for creating {@code $push} modifiers
 	 * 
 	 * @author Christoph Strobl
+	 * @author Thomas Darimont
 	 */
 	public class PushOperatorBuilder {
 
@@ -453,6 +559,50 @@ public class Update {
 		public Update value(Object value) {
 			return Update.this.push(key, value);
 		}
+
+		/* 
+		 * (non-Javadoc)
+		 * @see java.lang.Object#hashCode()
+		 */
+		@Override
+		public int hashCode() {
+
+			int result = 17;
+
+			result += 31 * result + getOuterType().hashCode();
+			result += 31 * result + nullSafeHashCode(key);
+			result += 31 * result + nullSafeHashCode(modifiers);
+
+			return result;
+		}
+
+		/* 
+		 * (non-Javadoc)
+		 * @see java.lang.Object#equals(java.lang.Object)
+		 */
+		@Override
+		public boolean equals(Object obj) {
+
+			if (this == obj) {
+				return true;
+			}
+
+			if (obj == null || getClass() != obj.getClass()) {
+				return false;
+			}
+
+			PushOperatorBuilder that = (PushOperatorBuilder) obj;
+
+			if (!getOuterType().equals(that.getOuterType())) {
+				return false;
+			}
+
+			return nullSafeEquals(this.key, that.key) && nullSafeEquals(this.modifiers, that.modifiers);
+		}
+
+		private Update getOuterType() {
+			return Update.this;
+		}
 	}
 
 	/**
@@ -488,7 +638,5 @@ public class Update {
 		public Update value(Object value) {
 			return Update.this.addToSet(this.key, value);
 		}
-
 	}
-
 }

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

@@ -19,10 +19,14 @@ import org.springframework.data.mapping.context.MappingContext;
 import org.springframework.data.mongodb.core.MongoOperations;
 import org.springframework.data.mongodb.core.MongoTemplate;
 import org.springframework.data.mongodb.core.mapping.MongoPersistentProperty;
+import org.springframework.data.mongodb.core.query.BasicQuery;
 import org.springframework.data.mongodb.core.query.Query;
 import org.springframework.data.repository.query.QueryMethod;
 import org.springframework.data.repository.query.RepositoryQuery;
 import org.springframework.data.repository.query.parser.PartTree;
+import org.springframework.util.StringUtils;
+
+import com.mongodb.util.JSONParseException;
 
 /**
  * {@link RepositoryQuery} implementation for Mongo.
@@ -67,7 +71,24 @@ public class PartTreeMongoQuery extends AbstractMongoQuery {
 	protected Query createQuery(ConvertingParameterAccessor accessor) {
 
 		MongoQueryCreator creator = new MongoQueryCreator(tree, accessor, context, isGeoNearQuery);
-		return creator.createQuery();
+		Query query = creator.createQuery();
+
+		String fieldSpec = this.getQueryMethod().getFieldSpecification();
+
+		if (!StringUtils.hasText(fieldSpec)) {
+			return query;
+		}
+
+		try {
+
+			BasicQuery result = new BasicQuery(query.getQueryObject().toString(), fieldSpec);
+			result.setSortObject(query.getSortObject());
+			return result;
+
+		} catch (JSONParseException o_O) {
+			throw new IllegalStateException(String.format("Invalid query or field specification in %s!", getQueryMethod(),
+					o_O));
+		}
 	}
 
 	/* 

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

@@ -2693,6 +2693,22 @@ public class MongoTemplateTests {
 		assertThat(result.getContent().getName(), is(content.getName()));
 	}
 
+	/**
+	 * @see DATAMONGO-970
+	 */
+	@Test
+	public void insertsAndRemovesBasicDbObjectCorrectly() {
+
+		BasicDBObject object = new BasicDBObject("key", "value");
+		template.insert(object, "collection");
+
+		assertThat(object.get("_id"), is(notNullValue()));
+		assertThat(template.findAll(DBObject.class, "collection"), hasSize(1));
+
+		template.remove(object, "collection");
+		assertThat(template.findAll(DBObject.class, "collection"), hasSize(0));
+	}
+
 	static class DoucmentWithNamedIdField {
 
 		@Id String someIdKey;

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

@@ -42,6 +42,7 @@ 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.domain.Sort;
 import org.springframework.data.mongodb.MongoDbFactory;
 import org.springframework.data.mongodb.core.convert.CustomConversions;
 import org.springframework.data.mongodb.core.convert.DefaultDbRefResolver;
@@ -50,11 +51,13 @@ import org.springframework.data.mongodb.core.convert.QueryMapper;
 import org.springframework.data.mongodb.core.index.MongoPersistentEntityIndexCreator;
 import org.springframework.data.mongodb.core.mapping.MongoMappingContext;
 import org.springframework.data.mongodb.core.query.BasicQuery;
+import org.springframework.data.mongodb.core.query.Criteria;
 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.BasicDBObjectBuilder;
 import com.mongodb.DB;
 import com.mongodb.DBCollection;
 import com.mongodb.DBCursor;
@@ -329,6 +332,26 @@ public class MongoTemplateUnitTests extends MongoOperationsUnitTests {
 		verify(collection, never()).remove(Mockito.any(DBObject.class));
 	}
 
+	/**
+	 * @see DATAMONGO-948
+	 */
+	@Test
+	public void sortShouldBeTakenAsIsWhenExecutingQueryWithoutSpecificTypeInformation() {
+
+		Query query = Query.query(Criteria.where("foo").is("bar")).with(new Sort("foo"));
+		template.executeQuery(query, "collection1", new DocumentCallbackHandler() {
+
+			@Override
+			public void processDocument(DBObject dbObject) throws MongoException, DataAccessException {
+				// nothing to do - just a test
+			}
+		});
+
+		ArgumentCaptor<DBObject> captor = ArgumentCaptor.forClass(DBObject.class);
+		verify(cursor, times(1)).sort(captor.capture());
+		assertThat(captor.getValue(), equalTo(new BasicDBObjectBuilder().add("foo", 1).get()));
+	}
+
 	class AutogenerateableId {
 
 		@Id BigInteger id;

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

@@ -20,10 +20,13 @@ import static org.hamcrest.collection.IsEmptyCollection.*;
 import static org.hamcrest.core.IsEqual.*;
 import static org.hamcrest.core.IsInstanceOf.*;
 import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
 
+import java.lang.annotation.Annotation;
 import java.util.Collections;
 import java.util.List;
 
+import org.hamcrest.collection.IsEmptyCollection;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Suite;
@@ -38,6 +41,9 @@ import org.springframework.data.mongodb.core.mapping.DBRef;
 import org.springframework.data.mongodb.core.mapping.Document;
 import org.springframework.data.mongodb.core.mapping.Field;
 import org.springframework.data.mongodb.core.mapping.MongoMappingContext;
+import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity;
+import org.springframework.data.mongodb.core.mapping.MongoPersistentEntityTestDummy.MongoPersistentEntityDummyBuilder;
+import org.springframework.data.mongodb.core.mapping.MongoPersistentProperty;
 
 import com.mongodb.BasicDBObjectBuilder;
 
@@ -289,9 +295,8 @@ public class MongoPersistentEntityIndexResolverUnitTests {
 			List<IndexDefinitionHolder> indexDefinitions = prepareMappingContextAndResolveIndexForType(CompoundIndexOnLevelZero.class);
 
 			IndexDefinition indexDefinition = indexDefinitions.get(0).getIndexDefinition();
-			assertThat(indexDefinition.getIndexOptions(),
-					equalTo(new BasicDBObjectBuilder().add("name", "compound_index").add("unique", true).add("dropDups", true)
-							.add("sparse", true).add("background", true).add("expireAfterSeconds", 10L).get()));
+			assertThat(indexDefinition.getIndexOptions(), equalTo(new BasicDBObjectBuilder().add("name", "compound_index")
+					.add("unique", true).add("dropDups", true).add("sparse", true).add("background", true).get()));
 			assertThat(indexDefinition.getIndexKeys(), equalTo(new BasicDBObjectBuilder().add("foo", 1).add("bar", -1).get()));
 		}
 
@@ -304,9 +309,8 @@ public class MongoPersistentEntityIndexResolverUnitTests {
 			List<IndexDefinitionHolder> indexDefinitions = prepareMappingContextAndResolveIndexForType(IndexDefinedOnSuperClass.class);
 
 			IndexDefinition indexDefinition = indexDefinitions.get(0).getIndexDefinition();
-			assertThat(indexDefinition.getIndexOptions(),
-					equalTo(new BasicDBObjectBuilder().add("name", "compound_index").add("unique", true).add("dropDups", true)
-							.add("sparse", true).add("background", true).add("expireAfterSeconds", 10L).get()));
+			assertThat(indexDefinition.getIndexOptions(), equalTo(new BasicDBObjectBuilder().add("name", "compound_index")
+					.add("unique", true).add("dropDups", true).add("sparse", true).add("background", true).get()));
 			assertThat(indexDefinition.getIndexKeys(), equalTo(new BasicDBObjectBuilder().add("foo", 1).add("bar", -1).get()));
 		}
 
@@ -322,7 +326,7 @@ public class MongoPersistentEntityIndexResolverUnitTests {
 			assertThat(
 					indexDefinition.getIndexOptions(),
 					equalTo(new BasicDBObjectBuilder().add("unique", true).add("dropDups", true).add("sparse", true)
-							.add("background", true).add("expireAfterSeconds", 10L).get()));
+							.add("background", true).get()));
 			assertThat(indexDefinition.getIndexKeys(), equalTo(new BasicDBObjectBuilder().add("foo", 1).add("bar", -1).get()));
 		}
 
@@ -364,6 +368,22 @@ public class MongoPersistentEntityIndexResolverUnitTests {
 			assertIndexPathAndCollection(new String[] { "foo", "bar" }, "CompoundIndexOnLevelZero", indexDefinitions.get(0));
 		}
 
+		/**
+		 * @see DATAMONGO-963
+		 */
+		@Test
+		public void compoundIndexShouldIncludeTTLWhenConsistingOfOnlyOneKey() {
+
+			List<IndexDefinitionHolder> indexDefinitions = prepareMappingContextAndResolveIndexForType(CompoundIndexWithOnlyOneKeyAndTTL.class);
+
+			IndexDefinition indexDefinition = indexDefinitions.get(0).getIndexDefinition();
+			assertThat(
+					indexDefinition.getIndexOptions(),
+					equalTo(new BasicDBObjectBuilder().add("unique", true).add("dropDups", true).add("sparse", true)
+							.add("background", true).add("expireAfterSeconds", 10L).get()));
+			assertThat(indexDefinition.getIndexKeys(), equalTo(new BasicDBObjectBuilder().add("foo", 1).get()));
+		}
+
 		@Document(collection = "CompoundIndexOnLevelOne")
 		static class CompoundIndexOnLevelOne {
 
@@ -400,6 +420,13 @@ public class MongoPersistentEntityIndexResolverUnitTests {
 		static class ComountIndexWithAutogeneratedName {
 
 		}
+
+		@Document(collection = "CompoundIndexWithOnlyOneKeyAndTTL")
+		@CompoundIndex(def = "{'foo': 1}", background = true, dropDups = true, expireAfterSeconds = 10, sparse = true,
+				unique = true)
+		static class CompoundIndexWithOnlyOneKeyAndTTL {
+
+		}
 	}
 
 	public static class MixedIndexResolutionTests {
@@ -469,9 +496,7 @@ public class MongoPersistentEntityIndexResolverUnitTests {
 
 			List<IndexDefinitionHolder> indexDefinitions = prepareMappingContextAndResolveIndexForType(CycleOnLevelOne.class);
 			assertIndexPathAndCollection("reference.indexedProperty", "cycleOnLevelOne", indexDefinitions.get(0));
-			assertIndexPathAndCollection("reference.cyclicReference.reference.indexedProperty", "cycleOnLevelOne",
-					indexDefinitions.get(1));
-			assertThat(indexDefinitions, hasSize(2));
+			assertThat(indexDefinitions, hasSize(1));
 		}
 
 		/**
@@ -488,6 +513,69 @@ public class MongoPersistentEntityIndexResolverUnitTests {
 			assertThat(indexDefinitions, hasSize(3));
 		}
 
+		/**
+		 * @see DATAMONGO-949
+		 */
+		@Test
+		public void shouldNotDetectCycleInSimilarlyNamedProperties() {
+
+			List<IndexDefinitionHolder> indexDefinitions = prepareMappingContextAndResolveIndexForType(SimilarityHolingBean.class);
+			assertIndexPathAndCollection("norm", "similarityHolingBean", indexDefinitions.get(0));
+			assertThat(indexDefinitions, hasSize(1));
+		}
+
+		/**
+		 * @see DATAMONGO-962
+		 */
+		@Test
+		public void shouldDetectSelfCycleViaCollectionTypeCorrectly() {
+
+			List<IndexDefinitionHolder> indexDefinitions = prepareMappingContextAndResolveIndexForType(SelfCyclingViaCollectionType.class);
+			assertThat(indexDefinitions, IsEmptyCollection.empty());
+		}
+
+		/**
+		 * @see DATAMONGO-962
+		 */
+		@Test
+		public void shouldNotDetectCycleWhenTypeIsUsedMoreThanOnce() {
+
+			List<IndexDefinitionHolder> indexDefinitions = prepareMappingContextAndResolveIndexForType(MultipleObjectsOfSameType.class);
+			assertThat(indexDefinitions, IsEmptyCollection.empty());
+		}
+
+		/**
+		 * @see DATAMONGO-962
+		 */
+		@Test
+		public void shouldCatchCyclicReferenceExceptionOnRoot() {
+
+			Document documentDummy = new Document() {
+
+				@Override
+				public Class<? extends Annotation> annotationType() {
+					return Document.class;
+				}
+
+				@Override
+				public String collection() {
+					return null;
+				}
+			};
+
+			MongoPersistentProperty propertyMock = mock(MongoPersistentProperty.class);
+			when(propertyMock.isEntity()).thenReturn(true);
+			when(propertyMock.getActualType()).thenThrow(
+					new MongoPersistentEntityIndexResolver.CyclicPropertyReferenceException("foo", Object.class, "bar"));
+
+			MongoPersistentEntity<SelfCyclingViaCollectionType> dummy = MongoPersistentEntityDummyBuilder
+					.forClass(SelfCyclingViaCollectionType.class).withCollection("foo").and(propertyMock)
+					.and(documentDummy).build();
+
+			new MongoPersistentEntityIndexResolver(prepareMappingContext(SelfCyclingViaCollectionType.class))
+					.resolveIndexForEntity(dummy);
+		}
+
 		@Document
 		static class MixedIndexRoot {
 
@@ -554,6 +642,32 @@ public class MongoPersistentEntityIndexResolverUnitTests {
 
 			@Indexed String foo;
 		}
+
+		@Document
+		static class SimilarityHolingBean {
+
+			@Indexed @Field("norm") String normalProperty;
+			@Field("similarityL") private List<SimilaritySibling> listOfSimilarilyNamedEntities = null;
+		}
+
+		static class SimilaritySibling {
+			@Field("similarity") private String similarThoughNotEqualNamedProperty;
+		}
+
+		@Document
+		static class MultipleObjectsOfSameType {
+
+			SelfCyclingViaCollectionType cycleOne;
+
+			SelfCyclingViaCollectionType cycleTwo;
+		}
+
+		@Document
+		static class SelfCyclingViaCollectionType {
+
+			List<SelfCyclingViaCollectionType> cyclic;
+
+		}
 	}
 
 	private static List<IndexDefinitionHolder> prepareMappingContextAndResolveIndexForType(Class<?> type) {
@@ -586,4 +700,5 @@ public class MongoPersistentEntityIndexResolverUnitTests {
 		}
 		assertThat(holder.getCollection(), equalTo(expectedCollection));
 	}
+
 }

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

@@ -0,0 +1,92 @@
+/*
+ * 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.
+ */
+package org.springframework.data.mongodb.core.index;
+
+import static org.hamcrest.CoreMatchers.*;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.springframework.data.mongodb.core.index.MongoPersistentEntityIndexResolver.CycleGuard.Path;
+import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity;
+import org.springframework.data.mongodb.core.mapping.MongoPersistentProperty;
+
+/**
+ * Unit tests for {@link Path}.
+ * 
+ * @author Christoph Strobl
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class PathUnitTests {
+
+	@Mock MongoPersistentEntity<?> entityMock;
+
+	@Before
+	@SuppressWarnings({ "rawtypes", "unchecked" })
+	public void setUp() {
+		when(entityMock.getType()).thenReturn((Class) Object.class);
+	}
+
+	/**
+	 * @see DATAMONGO-962
+	 */
+	@Test
+	public void shouldIdentifyCycleForOwnerOfSameTypeAndMatchingPath() {
+
+		MongoPersistentProperty property = createPersistentPropertyMock(entityMock, "foo");
+		assertThat(new Path(property, "foo.bar").cycles(property, "foo.bar.bar"), is(true));
+	}
+
+	/**
+	 * @see DATAMONGO-962
+	 */
+	@Test
+	@SuppressWarnings("rawtypes")
+	public void shouldAllowMatchingPathForDifferentOwners() {
+
+		MongoPersistentProperty existing = createPersistentPropertyMock(entityMock, "foo");
+
+		MongoPersistentEntity entityOfDifferentType = Mockito.mock(MongoPersistentEntity.class);
+		when(entityOfDifferentType.getType()).thenReturn(String.class);
+		MongoPersistentProperty toBeVerified = createPersistentPropertyMock(entityOfDifferentType, "foo");
+
+		assertThat(new Path(existing, "foo.bar").cycles(toBeVerified, "foo.bar.bar"), is(false));
+	}
+
+	/**
+	 * @see DATAMONGO-962
+	 */
+	@Test
+	public void shouldAllowEqaulPropertiesOnDifferentPaths() {
+
+		MongoPersistentProperty property = createPersistentPropertyMock(entityMock, "foo");
+		assertThat(new Path(property, "foo.bar").cycles(property, "foo2.bar.bar"), is(false));
+	}
+
+	@SuppressWarnings({ "rawtypes", "unchecked" })
+	private MongoPersistentProperty createPersistentPropertyMock(MongoPersistentEntity owner, String fieldname) {
+
+		MongoPersistentProperty property = Mockito.mock(MongoPersistentProperty.class);
+		when(property.getOwner()).thenReturn(owner);
+		when(property.getFieldName()).thenReturn(fieldname);
+		return property;
+	}
+}

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

@@ -0,0 +1,212 @@
+/*
+ * 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.
+ */
+package org.springframework.data.mongodb.core.mapping;
+
+import java.lang.annotation.Annotation;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.springframework.data.annotation.Id;
+import org.springframework.data.annotation.Version;
+import org.springframework.data.mapping.AssociationHandler;
+import org.springframework.data.mapping.PersistentProperty;
+import org.springframework.data.mapping.PreferredConstructor;
+import org.springframework.data.mapping.PropertyHandler;
+import org.springframework.data.mapping.SimpleAssociationHandler;
+import org.springframework.data.mapping.SimplePropertyHandler;
+import org.springframework.data.util.TypeInformation;
+
+/**
+ * Trivial dummy implementation of {@link MongoPersistentEntity} to be used in tests.
+ * 
+ * @author Christoph Strobl
+ * @param <T>
+ */
+public class MongoPersistentEntityTestDummy<T> implements MongoPersistentEntity<T> {
+
+	private Map<Class<?>, Annotation> annotations = new HashMap<Class<?>, Annotation>();
+	private Collection<MongoPersistentProperty> properties = new ArrayList<MongoPersistentProperty>();
+	private String collection;
+	private String name;
+	private Class<T> type;
+
+	@Override
+	public String getName() {
+		return name;
+	}
+
+	@Override
+	public PreferredConstructor<T, MongoPersistentProperty> getPersistenceConstructor() {
+		return null;
+	}
+
+	@Override
+	public boolean isConstructorArgument(PersistentProperty<?> property) {
+		return false;
+	}
+
+	@Override
+	public boolean isIdProperty(PersistentProperty<?> property) {
+		return property != null ? property.isIdProperty() : false;
+	}
+
+	@Override
+	public boolean isVersionProperty(PersistentProperty<?> property) {
+		return property != null ? property.isIdProperty() : false;
+	}
+
+	@Override
+	public MongoPersistentProperty getIdProperty() {
+		return getPersistentProperty(Id.class);
+	}
+
+	@Override
+	public MongoPersistentProperty getVersionProperty() {
+		return getPersistentProperty(Version.class);
+	}
+
+	@Override
+	public MongoPersistentProperty getPersistentProperty(String name) {
+
+		for (MongoPersistentProperty p : this.properties) {
+			if (p.getName().equals(name)) {
+				return p;
+			}
+		}
+		return null;
+	}
+
+	@Override
+	public MongoPersistentProperty getPersistentProperty(Class<? extends Annotation> annotationType) {
+
+		for (MongoPersistentProperty p : this.properties) {
+			if (p.isAnnotationPresent(annotationType)) {
+				return p;
+			}
+		}
+		return null;
+	}
+
+	@Override
+	public boolean hasIdProperty() {
+		return false;
+	}
+
+	@Override
+	public boolean hasVersionProperty() {
+		return getVersionProperty() != null;
+	}
+
+	@Override
+	public Class<T> getType() {
+		return this.type;
+	}
+
+	@Override
+	public Object getTypeAlias() {
+		return null;
+	}
+
+	@Override
+	public TypeInformation<T> getTypeInformation() {
+		return null;
+	}
+
+	@Override
+	public void doWithProperties(PropertyHandler<MongoPersistentProperty> handler) {
+
+		for (MongoPersistentProperty p : this.properties) {
+			handler.doWithPersistentProperty(p);
+		}
+	}
+
+	@Override
+	public void doWithProperties(SimplePropertyHandler handler) {
+
+		for (MongoPersistentProperty p : this.properties) {
+			handler.doWithPersistentProperty(p);
+		}
+	}
+
+	@Override
+	public void doWithAssociations(AssociationHandler<MongoPersistentProperty> handler) {
+
+	}
+
+	@Override
+	public void doWithAssociations(SimpleAssociationHandler handler) {
+
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public <A extends Annotation> A findAnnotation(Class<A> annotationType) {
+		return (A) this.annotations.get(annotationType);
+	}
+
+	@Override
+	public String getCollection() {
+		return this.collection;
+	}
+
+	/**
+	 * Simple builder to create {@link MongoPersistentEntityTestDummy} with defined properties.
+	 * 
+	 * @author Christoph Strobl
+	 * @param <T>
+	 */
+	public static class MongoPersistentEntityDummyBuilder<T> {
+
+		private MongoPersistentEntityTestDummy<T> instance;
+
+		private MongoPersistentEntityDummyBuilder(Class<T> type) {
+			this.instance = new MongoPersistentEntityTestDummy<T>();
+			this.instance.type = type;
+		}
+
+		@SuppressWarnings({ "rawtypes", "unchecked" })
+		public static <T> MongoPersistentEntityDummyBuilder<T> forClass(Class<T> type) {
+			return new MongoPersistentEntityDummyBuilder(type);
+		}
+
+		public MongoPersistentEntityDummyBuilder<T> withName(String name) {
+			this.instance.name = name;
+			return this;
+		}
+
+		public MongoPersistentEntityDummyBuilder<T> and(MongoPersistentProperty property) {
+			this.instance.properties.add(property);
+			return this;
+		}
+
+		public MongoPersistentEntityDummyBuilder<T> withCollection(String collection) {
+			this.instance.collection = collection;
+			return this;
+		}
+
+		public MongoPersistentEntityDummyBuilder<T> and(Annotation annotation) {
+			this.instance.annotations.put(annotation.annotationType(), annotation);
+			return this;
+		}
+
+		public MongoPersistentEntityTestDummy<T> build() {
+			return this.instance;
+		}
+
+	}
+}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011 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.
@@ -32,6 +32,7 @@ import org.junit.Ignore;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.geo.Box;
 import org.springframework.data.mongodb.MongoDbFactory;
 import org.springframework.data.mongodb.core.MongoTemplate;
 import org.springframework.data.mongodb.core.convert.DbRefResolver;
@@ -50,6 +51,7 @@ import com.mongodb.Mongo;
  * Integration test for {@link MongoTemplate}'s Map-Reduce operations
  * 
  * @author Mark Pollack
+ * @author Thomas Darimont
  */
 @RunWith(SpringJUnit4ClassRunner.class)
 @ContextConfiguration("classpath:infrastructure.xml")
@@ -276,6 +278,31 @@ public class MapReduceTests {
 
 	}
 
+	/**
+	 * @see DATAMONGO-938
+	 */
+	@Test
+	public void mapReduceShouldUseQueryMapper() {
+
+		DBCollection c = mongoTemplate.getDb().getCollection("jmrWithGeo");
+
+		c.save(new BasicDBObject("x", new String[] { "a", "b" }).append("loc", new double[] { 0, 0 }));
+		c.save(new BasicDBObject("x", new String[] { "b", "c" }).append("loc", new double[] { 0, 0 }));
+		c.save(new BasicDBObject("x", new String[] { "c", "d" }).append("loc", new double[] { 0, 0 }));
+
+		Query query = new Query(where("x").ne(new String[] { "a", "b" }).and("loc")
+				.within(new Box(new double[] { 0, 0 }, new double[] { 1, 1 })));
+
+		MapReduceResults<ValueObject> results = template.mapReduce(query, "jmrWithGeo", mapFunction, reduceFunction,
+				ValueObject.class);
+
+		Map<String, Float> m = copyToMap(results);
+		assertEquals(3, m.size());
+		assertEquals(1, m.get("b").intValue());
+		assertEquals(2, m.get("c").intValue());
+		assertEquals(1, m.get("d").intValue());
+	}
+
 	private void performMapReduce(boolean inline, boolean withQuery) {
 		createMapReduceData();
 		MapReduceResults<ValueObject> results;

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

@@ -30,6 +30,7 @@ import org.junit.Test;
  * @author Thomas Risberg
  * @author Becca Gaspard
  * @author Christoph Strobl
+ * @author Thomas Darimont
  */
 public class UpdateTests {
 
@@ -284,4 +285,61 @@ public class UpdateTests {
 	public void testCreatingUpdateWithNullKeyThrowsException() {
 		Update.update(null, "value");
 	}
+
+	/**
+	 * @see DATAMONGO-953
+	 */
+	@Test
+	public void testEquality() {
+
+		Update actualUpdate = new Update() //
+				.inc("size", 1) //
+				.set("nl", null) //
+				.set("directory", "/Users/Test/Desktop") //
+				.push("authors", Collections.singletonMap("name", "Sven")) //
+				.pop("authors", Update.Position.FIRST) //
+				.set("foo", "bar");
+
+		Update expectedUpdate = new Update() //
+				.inc("size", 1) //
+				.set("nl", null) //
+				.set("directory", "/Users/Test/Desktop") //
+				.push("authors", Collections.singletonMap("name", "Sven")) //
+				.pop("authors", Update.Position.FIRST) //
+				.set("foo", "bar");
+
+		assertThat(actualUpdate, is(equalTo(actualUpdate)));
+		assertThat(actualUpdate.hashCode(), is(equalTo(actualUpdate.hashCode())));
+		assertThat(actualUpdate, is(equalTo(expectedUpdate)));
+		assertThat(actualUpdate.hashCode(), is(equalTo(expectedUpdate.hashCode())));
+	}
+
+	/**
+	 * @see DATAMONGO-953
+	 */
+	@Test
+	public void testToString() {
+
+		Update actualUpdate = new Update() //
+				.inc("size", 1) //
+				.set("nl", null) //
+				.set("directory", "/Users/Test/Desktop") //
+				.push("authors", Collections.singletonMap("name", "Sven")) //
+				.pop("authors", Update.Position.FIRST) //
+				.set("foo", "bar");
+
+		Update expectedUpdate = new Update() //
+				.inc("size", 1) //
+				.set("nl", null) //
+				.set("directory", "/Users/Test/Desktop") //
+				.push("authors", Collections.singletonMap("name", "Sven")) //
+				.pop("authors", Update.Position.FIRST) //
+				.set("foo", "bar");
+
+		assertThat(actualUpdate.toString(), is(equalTo(expectedUpdate.toString())));
+		assertThat(actualUpdate.toString(), is("{ \"$inc\" : { \"size\" : 1} ," //
+				+ " \"$set\" : { \"nl\" :  null  , \"directory\" : \"/Users/Test/Desktop\" , \"foo\" : \"bar\"} , " //
+				+ "\"$push\" : { \"authors\" : { \"name\" : \"Sven\"}} " //
+				+ ", \"$pop\" : { \"authors\" : -1}}")); //
+	}
 }

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

@@ -880,4 +880,42 @@ public abstract class AbstractPersonRepositoryIntegrationTests {
 
 		assertThat(result.getContent(), hasSize(1));
 	}
+
+	/**
+	 * @see DATAMONGO-745
+	 */
+	@Test
+	public void findByCustomQueryFirstnamesInListAndLastname() {
+
+		repository.save(new Person("foo", "bar"));
+		repository.save(new Person("bar", "bar"));
+		repository.save(new Person("fuu", "bar"));
+		repository.save(new Person("notfound", "bar"));
+
+		Page<Person> result = repository.findByCustomQueryFirstnamesAndLastname(Arrays.asList("bar", "foo", "fuu"), "bar",
+				new PageRequest(0, 2));
+
+		assertThat(result.getContent(), hasSize(2));
+		assertThat(result.getTotalPages(), is(2));
+		assertThat(result.getTotalElements(), is(3L));
+	}
+
+	/**
+	 * @see DATAMONGO-745
+	 */
+	@Test
+	public void findByCustomQueryLastnameAndStreetInList() {
+
+		repository.save(new Person("foo", "bar").withAddress(new Address("street1", "1", "SB")));
+		repository.save(new Person("bar", "bar").withAddress(new Address("street2", "1", "SB")));
+		repository.save(new Person("fuu", "bar").withAddress(new Address("street1", "2", "RGB")));
+		repository.save(new Person("notfound", "notfound"));
+
+		Page<Person> result = repository.findByCustomQueryLastnameAndAddressStreetInList("bar",
+				Arrays.asList("street1", "street2"), new PageRequest(0, 2));
+
+		assertThat(result.getContent(), hasSize(2));
+		assertThat(result.getTotalPages(), is(2));
+		assertThat(result.getTotalElements(), is(3L));
+	}
 }

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

@@ -261,6 +261,12 @@ public class Person extends Contact {
 		return this.getId().equals(that.getId());
 	}
 
+	public Person withAddress(Address address) {
+
+		this.address = address;
+		return this;
+	}
+
 	/*
 	* (non-Javadoc)
 	*

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

@@ -290,4 +290,16 @@ public interface PersonRepository extends MongoRepository<Person, String>, Query
 	 * @see DATAMONGO-893
 	 */
 	Page<Person> findByAddressIn(List<Address> address, Pageable page);
+
+	/**
+	 * @see DATAMONGO-745
+	 */
+	@Query("{firstname:{$in:?0}, lastname:?1}")
+	Page<Person> findByCustomQueryFirstnamesAndLastname(List<String> firstnames, String lastname, Pageable page);
+
+	/**
+	 * @see DATAMONGO-745
+	 */
+	@Query("{lastname:?0, address.street:{$in:?1}}")
+	Page<Person> findByCustomQueryLastnameAndAddressStreetInList(String lastname, List<String> streetNames, Pageable page);
 }

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

@@ -0,0 +1,166 @@
+/*
+ * 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.
+ */
+package org.springframework.data.mongodb.repository.query;
+
+import static org.hamcrest.CoreMatchers.*;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+
+import java.lang.reflect.Method;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.junit.runner.RunWith;
+import org.mockito.Matchers;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.springframework.data.mongodb.MongoDbFactory;
+import org.springframework.data.mongodb.core.MongoOperations;
+import org.springframework.data.mongodb.core.convert.DbRefResolver;
+import org.springframework.data.mongodb.core.convert.DefaultDbRefResolver;
+import org.springframework.data.mongodb.core.convert.MappingMongoConverter;
+import org.springframework.data.mongodb.core.convert.MongoConverter;
+import org.springframework.data.mongodb.core.mapping.MongoMappingContext;
+import org.springframework.data.mongodb.repository.MongoRepository;
+import org.springframework.data.mongodb.repository.Person;
+import org.springframework.data.mongodb.repository.Query;
+import org.springframework.data.repository.core.RepositoryMetadata;
+
+import com.mongodb.BasicDBObjectBuilder;
+
+/**
+ * Unit tests for {@link PartTreeMongoQuery}.
+ * 
+ * @author Christoph Strobl
+ * @author Oliver Gierke
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class PartTreeMongoQueryUnitTests {
+
+	@Mock RepositoryMetadata metadataMock;
+	@Mock MongoOperations mongoOperationsMock;
+
+	MongoMappingContext mappingContext;
+
+	public @Rule ExpectedException exception = ExpectedException.none();
+
+	@Before
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	public void setUp() {
+
+		when(metadataMock.getDomainType()).thenReturn((Class) Person.class);
+		when(metadataMock.getReturnedDomainClass(Matchers.any(Method.class))).thenReturn((Class) Person.class);
+		mappingContext = new MongoMappingContext();
+		DbRefResolver dbRefResolver = new DefaultDbRefResolver(mock(MongoDbFactory.class));
+		MongoConverter converter = new MappingMongoConverter(dbRefResolver, mappingContext);
+
+		when(mongoOperationsMock.getConverter()).thenReturn(converter);
+	}
+
+	/**
+	 * @see DATAMOGO-952
+	 */
+	@Test
+	public void rejectsInvalidFieldSpecification() {
+
+		exception.expect(IllegalStateException.class);
+		exception.expectMessage("findByLastname");
+
+		deriveQueryFromMethod("findByLastname", new Object[] { "foo" });
+	}
+
+	/**
+	 * @see DATAMOGO-952
+	 */
+	@Test
+	public void singleFieldJsonIncludeRestrictionShouldBeConsidered() {
+
+		org.springframework.data.mongodb.core.query.Query query = deriveQueryFromMethod("findByFirstname",
+				new Object[] { "foo" });
+
+		assertThat(query.getFieldsObject(), is(new BasicDBObjectBuilder().add("firstname", 1).get()));
+	}
+
+	/**
+	 * @see DATAMOGO-952
+	 */
+	@Test
+	public void multiFieldJsonIncludeRestrictionShouldBeConsidered() {
+
+		org.springframework.data.mongodb.core.query.Query query = deriveQueryFromMethod("findByFirstnameAndLastname",
+				new Object[] { "foo", "bar" });
+
+		assertThat(query.getFieldsObject(), is(new BasicDBObjectBuilder().add("firstname", 1).add("lastname", 1).get()));
+	}
+
+	/**
+	 * @see DATAMOGO-952
+	 */
+	@Test
+	public void multiFieldJsonExcludeRestrictionShouldBeConsidered() {
+
+		org.springframework.data.mongodb.core.query.Query query = deriveQueryFromMethod("findPersonByFirstnameAndLastname",
+				new Object[] { "foo", "bar" });
+
+		assertThat(query.getFieldsObject(), is(new BasicDBObjectBuilder().add("firstname", 0).add("lastname", 0).get()));
+	}
+
+	private org.springframework.data.mongodb.core.query.Query deriveQueryFromMethod(String method, Object[] args) {
+
+		Class<?>[] types = new Class<?>[args.length];
+
+		for (int i = 0; i < args.length; i++) {
+			types[i] = args[i].getClass();
+		}
+
+		PartTreeMongoQuery partTreeQuery = createQueryForMethod(method, types);
+
+		MongoParameterAccessor accessor = new MongoParametersParameterAccessor(partTreeQuery.getQueryMethod(), args);
+		return partTreeQuery.createQuery(new ConvertingParameterAccessor(mongoOperationsMock.getConverter(), accessor));
+	}
+
+	private PartTreeMongoQuery createQueryForMethod(String methodName, Class<?>... paramTypes) {
+
+		try {
+
+			Method method = Repo.class.getMethod(methodName, paramTypes);
+			MongoQueryMethod queryMethod = new MongoQueryMethod(method, metadataMock, mappingContext);
+
+			return new PartTreeMongoQuery(queryMethod, mongoOperationsMock);
+		} catch (NoSuchMethodException e) {
+			throw new IllegalArgumentException(e.getMessage(), e);
+		} catch (SecurityException e) {
+			throw new IllegalArgumentException(e.getMessage(), e);
+		}
+	}
+
+	interface Repo extends MongoRepository<Person, Long> {
+
+		@Query(fields = "firstname")
+		Person findByLastname(String lastname);
+
+		@Query(fields = "{ 'firstname' : 1 }")
+		Person findByFirstname(String lastname);
+
+		@Query(fields = "{ 'firstname' : 1, 'lastname' : 1 }")
+		Person findByFirstnameAndLastname(String firstname, String lastname);
+
+		@Query(fields = "{ 'firstname' : 0, 'lastname' : 0 }")
+		Person findPersonByFirstnameAndLastname(String firstname, String lastname);
+	}
+}

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.8.0.RELEASE/src/docbkx/repositories.xml">
+    <xi:include href="https://raw.github.com/spring-projects/spring-data-commons/1.8.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.8.0.RELEASE/src/docbkx/repository-namespace-reference.xml">
+    <xi:include href="https://raw.github.com/spring-projects/spring-data-commons/1.8.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.8.0.RELEASE/src/docbkx/repository-query-keywords-reference.xml">
+    <xi:include href="https://raw.github.com/spring-projects/spring-data-commons/1.8.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/main/resources/changelog.txt

@@ -1,6 +1,39 @@
 Spring Data MongoDB Changelog
 =============================
 
+Changes in version 1.5.1.RELEASE (2014-06-30)
+---------------------------------------------
+* DATAMONGO-971 - Release 1.5.1.
+* DATAMONGO-970 - Id query cannot be created if object to remove is DBObject.
+* DATAMONGO-963 - Compound index with expireAfterSeconds causes repeating error on mongodb server.
+* DATAMONGO-962 - “Cycle found” with Spring Data Mongo 1.5.
+* DATAMONGO-953 - Update object should have a proper equals/hashcode/toString.
+* DATAMONGO-952 - @Query annotation does not work with only field restrictions.
+* DATAMONGO-949 - CyclicPropertyReferenceException in versions 1.5.0 + for MongoDB.
+* DATAMONGO-948 - Assertion error in MongoTemplate.getMappedSortObject.
+* DATAMONGO-938 - Exception when creating geo within Criteria using MapReduce.
+* DATAMONGO-745 - @Query($in) and Pageable in result Page total = 0.
+
+
+Changes in version 1.4.3.RELEASE (2014-06-18)
+---------------------------------------------
+* DATAMONGO-955 - Release 1.4.3.
+* DATAMONGO-953 - Update object should have a proper equals/hashcode/toString.
+* DATAMONGO-952 - @Query annotation does not work with only field restrictions.
+* DATAMONGO-948 - Assertion error in MongoTemplate.getMappedSortObject.
+* DATAMONGO-938 - Exception when creating geo within Criteria using MapReduce.
+* DATAMONGO-924 - Aggregation not working with as() method in project() pipeline operator.
+* DATAMONGO-920 - Fix debug messages for delete events in AbstractMongoEventListener.
+* DATAMONGO-917 - DefaultDbRefResolver throws NPE when bundled into an uberjar.
+* DATAMONGO-914 - Improve resolving of LazyLoading proxies for classes that override equals/hashcode.
+* DATAMONGO-913 - Can't query using lazy DBRef objects.
+* DATAMONGO-912 - Aggregation#project followed by Aggregation#match with custom converter causes IllegalArgumentException.
+* DATAMONGO-898 - MapReduce seems not to work when javascript not being escaped.
+* DATAMONGO-847 - Allow usage of Criteria within Update.
+* DATAMONGO-745 - @Query($in) and Pageable in result Page total = 0.
+* DATAMONGO-647 - Using "OrderBy" in "query by method name" ignores the @Field annotation for field alias.
+
+
 Changes in version 1.5.0.RELEASE (2014-05-20)
 ---------------------------------------------
 * DATAMONGO-936 - Release 1.5 GA.

src/main/resources/notice.txt

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