diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/aggregation/ArithmeticOperators.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/aggregation/ArithmeticOperators.java
index 4de258b4e..7896486ab 100644
--- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/aggregation/ArithmeticOperators.java
+++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/aggregation/ArithmeticOperators.java
@@ -678,34 +678,37 @@ public class ArithmeticOperators {
}
/**
- * Creates new {@link AggregationExpression} that calculates the sine of a numeric value given in {@link AngularDimension#RADIANS radians}.
+ * Creates new {@link AggregationExpression} that calculates the sine of a numeric value given in
+ * {@link AngularUnit#RADIANS radians}.
*
* @return new instance of {@link Sin}.
* @since 3.3
*/
public Sin sin() {
- return sin(AngularDimension.RADIANS);
+ return sin(AngularUnit.RADIANS);
}
/**
- * Creates new {@link AggregationExpression} that calculates the sine of a numeric value in the given {@link AngularDimension unit}.
+ * Creates new {@link AggregationExpression} that calculates the sine of a numeric value in the given
+ * {@link AngularUnit unit}.
*
* @param unit the unit of measure.
* @return new instance of {@link Sin}.
* @since 3.3
*/
- public Sin sin(AngularDimension unit) {
+ public Sin sin(AngularUnit unit) {
return usesFieldRef() ? Sin.sinOf(fieldReference, unit) : Sin.sinOf(expression, unit);
}
/**
- * Creates new {@link AggregationExpression} that calculates the sine of a numeric value given in {@link AngularDimension#RADIANS radians}.
+ * Creates new {@link AggregationExpression} that calculates the sine of a numeric value given in
+ * {@link AngularUnit#RADIANS radians}.
*
* @return new instance of {@link Sin}.
* @since 3.3
*/
public Sinh sinh() {
- return sinh(AngularDimension.RADIANS);
+ return sinh(AngularUnit.RADIANS);
}
/**
@@ -715,42 +718,42 @@ public class ArithmeticOperators {
* @return new instance of {@link Sin}.
* @since 3.3
*/
- public Sinh sinh(AngularDimension unit) {
+ public Sinh sinh(AngularUnit unit) {
return usesFieldRef() ? Sinh.sinhOf(fieldReference, unit) : Sinh.sinhOf(expression, unit);
}
/**
* Creates new {@link AggregationExpression} that calculates the cosine of a numeric value given in
- * {@link AngularDimension#RADIANS radians}.
+ * {@link AngularUnit#RADIANS radians}.
*
* @return new instance of {@link Sin}.
* @since 3.3
*/
public Cos cos() {
- return cos(AngularDimension.RADIANS);
+ return cos(AngularUnit.RADIANS);
}
/**
* Creates new {@link AggregationExpression} that calculates the cosine of a numeric value in the given
- * {@link AngularDimension unit}.
+ * {@link AngularUnit unit}.
*
* @param unit the unit of measure.
* @return new instance of {@link Sin}.
* @since 3.3
*/
- public Cos cos(AngularDimension unit) {
+ public Cos cos(AngularUnit unit) {
return usesFieldRef() ? Cos.cosOf(fieldReference, unit) : Cos.cosOf(expression, unit);
}
/**
* Creates new {@link AggregationExpression} that calculates the hyperbolic cosine of a numeric value given in
- * {@link AngularDimension#RADIANS radians}.
+ * {@link AngularUnit#RADIANS radians}.
*
* @return new instance of {@link Sin}.
* @since 3.3
*/
public Cosh cosh() {
- return cosh(AngularDimension.RADIANS);
+ return cosh(AngularUnit.RADIANS);
}
/**
@@ -760,42 +763,42 @@ public class ArithmeticOperators {
* @return new instance of {@link Sin}.
* @since 3.3
*/
- public Cosh cosh(AngularDimension unit) {
+ public Cosh cosh(AngularUnit unit) {
return usesFieldRef() ? Cosh.coshOf(fieldReference, unit) : Cosh.coshOf(expression, unit);
}
/**
* Creates new {@link AggregationExpression} that calculates the tangent of a numeric value given in
- * {@link AngularDimension#RADIANS radians}.
+ * {@link AngularUnit#RADIANS radians}.
*
* @return new instance of {@link Sin}.
* @since 3.3
*/
public Tan tan() {
- return tan(AngularDimension.RADIANS);
+ return tan(AngularUnit.RADIANS);
}
/**
* Creates new {@link AggregationExpression} that calculates the tangent of a numeric value in the given
- * {@link AngularDimension unit}.
+ * {@link AngularUnit unit}.
*
* @param unit the unit of measure.
* @return new instance of {@link Sin}.
* @since 3.3
*/
- public Tan tan(AngularDimension unit) {
+ public Tan tan(AngularUnit unit) {
return usesFieldRef() ? Tan.tanOf(fieldReference, unit) : Tan.tanOf(expression, unit);
}
/**
* Creates new {@link AggregationExpression} that calculates the hyperbolic tangent of a numeric value given in
- * {@link AngularDimension#RADIANS radians}.
+ * {@link AngularUnit#RADIANS radians}.
*
* @return new instance of {@link Sin}.
* @since 3.3
*/
public Tanh tanh() {
- return tanh(AngularDimension.RADIANS);
+ return tanh(AngularUnit.RADIANS);
}
/**
@@ -805,7 +808,7 @@ public class ArithmeticOperators {
* @return new instance of {@link Sin}.
* @since 3.3
*/
- public Tanh tanh(AngularDimension unit) {
+ public Tanh tanh(AngularUnit unit) {
return usesFieldRef() ? Tanh.tanhOf(fieldReference, unit) : Tanh.tanhOf(expression, unit);
}
@@ -2047,7 +2050,7 @@ public class ArithmeticOperators {
* @author Christoph Strobl
* @since 3.3
*/
- public enum AngularDimension {
+ public enum AngularUnit {
RADIANS, DEGREES
}
@@ -2065,76 +2068,82 @@ public class ArithmeticOperators {
/**
* Creates a new {@link AggregationExpression} that calculates the sine of a value that is measured in
- * {@link AngularDimension#RADIANS radians}.
+ * {@link AngularUnit#RADIANS radians}.
*
- * Use {@code sinhOf("angle", DEGREES)} as shortcut for { $sinh : { $degreesToRadians : "$angle" } }.
+ * Use {@code sinhOf("angle", DEGREES)} as shortcut for
+ *
+ *
+ * { $sinh : { $degreesToRadians : "$angle" } }
+ *
+ *
+ * .
*
* @param fieldReference the name of the {@link Field field} that resolves to a numeric value.
* @return new instance of {@link Sin}.
*/
public static Sin sinOf(String fieldReference) {
- return sinOf(fieldReference, AngularDimension.RADIANS);
+ return sinOf(fieldReference, AngularUnit.RADIANS);
}
/**
* Creates a new {@link AggregationExpression} that calculates the sine of a value that is measured in the given
- * {@link AngularDimension unit}.
+ * {@link AngularUnit unit}.
*
* @param fieldReference the name of the {@link Field field} that resolves to a numeric value.
* @param unit the unit of measure used by the value of the given field.
* @return new instance of {@link Sin}.
*/
- public static Sin sinOf(String fieldReference, AngularDimension unit) {
+ public static Sin sinOf(String fieldReference, AngularUnit unit) {
return sin(Fields.field(fieldReference), unit);
}
/**
* Creates a new {@link AggregationExpression} that calculates the sine of a value that is measured in
- * {@link AngularDimension#RADIANS}.
+ * {@link AngularUnit#RADIANS}.
*
* @param expression the {@link AggregationExpression expression} that resolves to a numeric value.
* @return new instance of {@link Sin}.
*/
public static Sin sinOf(AggregationExpression expression) {
- return sinOf(expression, AngularDimension.RADIANS);
+ return sinOf(expression, AngularUnit.RADIANS);
}
/**
* Creates a new {@link AggregationExpression} that calculates the sine of a value that is measured in the given
- * {@link AngularDimension unit}.
+ * {@link AngularUnit unit}.
*
* @param expression the {@link AggregationExpression expression} that resolves to a numeric value.
* @param unit the unit of measure used by the value of the given field.
* @return new instance of {@link Sin}.
*/
- public static Sin sinOf(AggregationExpression expression, AngularDimension unit) {
+ public static Sin sinOf(AggregationExpression expression, AngularUnit unit) {
return sin(expression, unit);
}
/**
* Creates a new {@link AggregationExpression} that calculates the sine of a value that is measured in
- * {@link AngularDimension#RADIANS}.
+ * {@link AngularUnit#RADIANS}.
*
* @param value anything ({@link Field field}, {@link AggregationExpression expression}, ...) that resolves to a
* numeric value
* @return new instance of {@link Sin}.
*/
public static Sin sin(Object value) {
- return sin(value, AngularDimension.RADIANS);
+ return sin(value, AngularUnit.RADIANS);
}
/**
* Creates a new {@link AggregationExpression} that calculates the sine of a value that is measured in the given
- * {@link AngularDimension unit}.
+ * {@link AngularUnit unit}.
*
* @param value anything ({@link Field field}, {@link AggregationExpression expression}, ...) that resolves to a
* numeric value.
* @param unit the unit of measure used by the value of the given field.
* @return new instance of {@link Sin}.
*/
- public static Sin sin(Object value, AngularDimension unit) {
+ public static Sin sin(Object value, AngularUnit unit) {
- if (ObjectUtils.nullSafeEquals(AngularDimension.DEGREES, unit)) {
+ if (ObjectUtils.nullSafeEquals(AngularUnit.DEGREES, unit)) {
return new Sin(ConvertOperators.DegreesToRadians.degreesToRadians(value));
}
return new Sin(value);
@@ -2148,7 +2157,7 @@ public class ArithmeticOperators {
/**
* An {@link AggregationExpression expression} that calculates the hyperbolic sine of a value that is measured in
- * {@link AngularDimension#RADIANS}.
+ * {@link AngularUnit#RADIANS}.
*
* @author Christoph Strobl
* @since 3.3
@@ -2161,78 +2170,85 @@ public class ArithmeticOperators {
/**
* Creates a new {@link AggregationExpression} that calculates the hyperbolic sine of a value that is measured in
- * {@link AngularDimension#RADIANS}.
+ * {@link AngularUnit#RADIANS}.
*
* @param fieldReference the name of the {@link Field field} that resolves to a numeric value.
* @return new instance of {@link Sin}.
*/
public static Sinh sinhOf(String fieldReference) {
- return sinhOf(fieldReference, AngularDimension.RADIANS);
+ return sinhOf(fieldReference, AngularUnit.RADIANS);
}
/**
* Creates a new {@link AggregationExpression} that calculates the hyperbolic sine of a value that is measured in
- * the given {@link AngularDimension unit}.
+ * the given {@link AngularUnit unit}.
*
- * Use {@code sinhOf("angle", DEGREES)} as shortcut for { $sinh : { $degreesToRadians : "$angle" } }.
+ * Use {@code sinhOf("angle", DEGREES)} as shortcut for
+ *
+ *
+ * { $sinh : { $degreesToRadians : "$angle" } }
+ *
+ *
+ * .
*
* @param fieldReference the name of the {@link Field field} that resolves to a numeric value.
* @param unit the unit of measure used by the value of the given field.
* @return new instance of {@link Sin}.
*/
- public static Sinh sinhOf(String fieldReference, AngularDimension unit) {
+ public static Sinh sinhOf(String fieldReference, AngularUnit unit) {
return sinh(Fields.field(fieldReference), unit);
}
/**
* Creates a new {@link AggregationExpression} that calculates the hyperbolic sine of a value that is measured in
- * {@link AngularDimension#RADIANS}.
+ * {@link AngularUnit#RADIANS}.
*
- * Use {@code sinhOf("angle", DEGREES)} as shortcut for eg. {@code sinhOf(ConvertOperators.valueOf("angle").degreesToRadians())}.
+ * Use {@code sinhOf("angle", DEGREES)} as shortcut for eg.
+ * {@code sinhOf(ConvertOperators.valueOf("angle").degreesToRadians())}.
*
* @param expression the {@link AggregationExpression expression} that resolves to a numeric value.
* @return new instance of {@link Sin}.
*/
public static Sinh sinhOf(AggregationExpression expression) {
- return sinhOf(expression, AngularDimension.RADIANS);
+ return sinhOf(expression, AngularUnit.RADIANS);
}
/**
* Creates a new {@link AggregationExpression} that calculates the hyperbolic sine of a value that is measured in
- * the given {@link AngularDimension unit}.
+ * the given {@link AngularUnit unit}.
*
* @param expression the {@link AggregationExpression expression} that resolves to a numeric value.
* @param unit the unit of measure used by the value of the given field.
* @return new instance of {@link Sin}.
*/
- public static Sinh sinhOf(AggregationExpression expression, AngularDimension unit) {
+ public static Sinh sinhOf(AggregationExpression expression, AngularUnit unit) {
return sinh(expression, unit);
}
/**
* Creates a new {@link AggregationExpression} that calculates the hyperbolic sine of a value that is measured in
- * {@link AngularDimension#RADIANS}.
+ * {@link AngularUnit#RADIANS}.
*
* @param value anything ({@link Field field}, {@link AggregationExpression expression}, ...) that resolves to a
* numeric value.
* @return new instance of {@link Sin}.
*/
public static Sinh sinh(Object value) {
- return sinh(value, AngularDimension.RADIANS);
+ return sinh(value, AngularUnit.RADIANS);
}
/**
* Creates a new {@link AggregationExpression} that calculates the hyperbolic sine of a value that is measured in
- * the given {@link AngularDimension unit}.
+ * the given {@link AngularUnit unit}.
*
* @param value anything ({@link Field field}, {@link AggregationExpression expression}, ...) that resolves to a
* numeric value
* @param unit the unit of measure used by the value of the given field.
* @return new instance of {@link Sin}.
*/
- public static Sinh sinh(Object value, AngularDimension unit) {
+ public static Sinh sinh(Object value, AngularUnit unit) {
- if (ObjectUtils.nullSafeEquals(AngularDimension.DEGREES, unit)) {
+ if (ObjectUtils.nullSafeEquals(AngularUnit.DEGREES, unit)) {
return new Sinh(ConvertOperators.DegreesToRadians.degreesToRadians(value));
}
return new Sinh(value);
@@ -2258,82 +2274,82 @@ public class ArithmeticOperators {
/**
* Creates a new {@link AggregationExpression} that calculates the cosine of a value that is measured in
- * {@link AngularDimension#RADIANS radians}.
+ * {@link AngularUnit#RADIANS radians}.
*
* Use {@code cosOf("angle", DEGREES)} as shortcut for
- *
+ *
*
* { $cos : { $degreesToRadians : "$angle" } }
*
- *
+ *
* .
*
* @param fieldReference the name of the {@link Field field} that resolves to a numeric value.
* @return new instance of {@link Cos}.
*/
public static Cos cosOf(String fieldReference) {
- return cosOf(fieldReference, AngularDimension.RADIANS);
+ return cosOf(fieldReference, AngularUnit.RADIANS);
}
/**
* Creates a new {@link AggregationExpression} that calculates the cosine of a value that is measured in the given
- * {@link AngularDimension unit}.
+ * {@link AngularUnit unit}.
*
* @param fieldReference the name of the {@link Field field} that resolves to a numeric value.
* @param unit the unit of measure used by the value of the given field.
* @return new instance of {@link Cos}.
*/
- public static Cos cosOf(String fieldReference, AngularDimension unit) {
+ public static Cos cosOf(String fieldReference, AngularUnit unit) {
return cos(Fields.field(fieldReference), unit);
}
/**
* Creates a new {@link AggregationExpression} that calculates the cosine of a value that is measured in
- * {@link AngularDimension#RADIANS}.
+ * {@link AngularUnit#RADIANS}.
*
* @param expression the {@link AggregationExpression expression} that resolves to a numeric value.
* @return new instance of {@link Cos}.
*/
public static Cos cosOf(AggregationExpression expression) {
- return cosOf(expression, AngularDimension.RADIANS);
+ return cosOf(expression, AngularUnit.RADIANS);
}
/**
* Creates a new {@link AggregationExpression} that calculates the cosine of a value that is measured in the given
- * {@link AngularDimension unit}.
+ * {@link AngularUnit unit}.
*
* @param expression the {@link AggregationExpression expression} that resolves to a numeric value.
* @param unit the unit of measure used by the value of the given field.
* @return new instance of {@link Cos}.
*/
- public static Cos cosOf(AggregationExpression expression, AngularDimension unit) {
+ public static Cos cosOf(AggregationExpression expression, AngularUnit unit) {
return cos(expression, unit);
}
/**
* Creates a new {@link AggregationExpression} that calculates the cosine of a value that is measured in
- * {@link AngularDimension#RADIANS}.
+ * {@link AngularUnit#RADIANS}.
*
* @param value anything ({@link Field field}, {@link AggregationExpression expression}, ...) that resolves to a
* numeric value
* @return new instance of {@link Cos}.
*/
public static Cos cos(Object value) {
- return cos(value, AngularDimension.RADIANS);
+ return cos(value, AngularUnit.RADIANS);
}
/**
* Creates a new {@link AggregationExpression} that calculates the cosine of a value that is measured in the given
- * {@link AngularDimension unit}.
+ * {@link AngularUnit unit}.
*
* @param value anything ({@link Field field}, {@link AggregationExpression expression}, ...) that resolves to a
* numeric value.
* @param unit the unit of measure used by the value of the given field.
* @return new instance of {@link Cos}.
*/
- public static Cos cos(Object value, AngularDimension unit) {
+ public static Cos cos(Object value, AngularUnit unit) {
- if (ObjectUtils.nullSafeEquals(AngularDimension.DEGREES, unit)) {
+ if (ObjectUtils.nullSafeEquals(AngularUnit.DEGREES, unit)) {
return new Cos(ConvertOperators.DegreesToRadians.degreesToRadians(value));
}
return new Cos(value);
@@ -2347,7 +2363,7 @@ public class ArithmeticOperators {
/**
* An {@link AggregationExpression expression} that calculates the hyperbolic cosine of a value that is measured in
- * {@link AngularDimension#RADIANS}.
+ * {@link AngularUnit#RADIANS}.
*
* @author Christoph Strobl
* @since 3.3
@@ -2360,38 +2376,38 @@ public class ArithmeticOperators {
/**
* Creates a new {@link AggregationExpression} that calculates the hyperbolic cosine of a value that is measured in
- * {@link AngularDimension#RADIANS}.
+ * {@link AngularUnit#RADIANS}.
*
* @param fieldReference the name of the {@link Field field} that resolves to a numeric value.
* @return new instance of {@link Cosh}.
*/
public static Cosh coshOf(String fieldReference) {
- return coshOf(fieldReference, AngularDimension.RADIANS);
+ return coshOf(fieldReference, AngularUnit.RADIANS);
}
/**
* Creates a new {@link AggregationExpression} that calculates the hyperbolic cosine of a value that is measured in
- * the given {@link AngularDimension unit}.
+ * the given {@link AngularUnit unit}.
*
* Use {@code coshOf("angle", DEGREES)} as shortcut for
- *
+ *
*
* { $cosh : { $degreesToRadians : "$angle" } }
*
- *
+ *
* .
*
* @param fieldReference the name of the {@link Field field} that resolves to a numeric value.
* @param unit the unit of measure used by the value of the given field.
* @return new instance of {@link Cosh}.
*/
- public static Cosh coshOf(String fieldReference, AngularDimension unit) {
+ public static Cosh coshOf(String fieldReference, AngularUnit unit) {
return cosh(Fields.field(fieldReference), unit);
}
/**
* Creates a new {@link AggregationExpression} that calculates the hyperbolic cosine of a value that is measured in
- * {@link AngularDimension#RADIANS}.
+ * {@link AngularUnit#RADIANS}.
*
* Use {@code sinhOf("angle", DEGREES)} as shortcut for eg.
* {@code sinhOf(ConvertOperators.valueOf("angle").degreesToRadians())}.
@@ -2400,45 +2416,45 @@ public class ArithmeticOperators {
* @return new instance of {@link Cosh}.
*/
public static Cosh coshOf(AggregationExpression expression) {
- return coshOf(expression, AngularDimension.RADIANS);
+ return coshOf(expression, AngularUnit.RADIANS);
}
/**
* Creates a new {@link AggregationExpression} that calculates the hyperbolic cosine of a value that is measured in
- * the given {@link AngularDimension unit}.
+ * the given {@link AngularUnit unit}.
*
* @param expression the {@link AggregationExpression expression} that resolves to a numeric value.
* @param unit the unit of measure used by the value of the given field.
* @return new instance of {@link Cosh}.
*/
- public static Cosh coshOf(AggregationExpression expression, AngularDimension unit) {
+ public static Cosh coshOf(AggregationExpression expression, AngularUnit unit) {
return cosh(expression, unit);
}
/**
* Creates a new {@link AggregationExpression} that calculates the hyperbolic cosine of a value that is measured in
- * {@link AngularDimension#RADIANS}.
+ * {@link AngularUnit#RADIANS}.
*
* @param value anything ({@link Field field}, {@link AggregationExpression expression}, ...) that resolves to a
* numeric value.
* @return new instance of {@link Cosh}.
*/
public static Cosh cosh(Object value) {
- return cosh(value, AngularDimension.RADIANS);
+ return cosh(value, AngularUnit.RADIANS);
}
/**
* Creates a new {@link AggregationExpression} that calculates the hyperbolic cosine of a value that is measured in
- * the given {@link AngularDimension unit}.
+ * the given {@link AngularUnit unit}.
*
* @param value anything ({@link Field field}, {@link AggregationExpression expression}, ...) that resolves to a
* numeric value
* @param unit the unit of measure used by the value of the given field.
* @return new instance of {@link Cosh}.
*/
- public static Cosh cosh(Object value, AngularDimension unit) {
+ public static Cosh cosh(Object value, AngularUnit unit) {
- if (ObjectUtils.nullSafeEquals(AngularDimension.DEGREES, unit)) {
+ if (ObjectUtils.nullSafeEquals(AngularUnit.DEGREES, unit)) {
return new Cosh(ConvertOperators.DegreesToRadians.degreesToRadians(value));
}
return new Cosh(value);
@@ -2464,82 +2480,82 @@ public class ArithmeticOperators {
/**
* Creates a new {@link AggregationExpression} that calculates the tangent of a value that is measured in
- * {@link AngularDimension#RADIANS radians}.
+ * {@link AngularUnit#RADIANS radians}.
*
* Use {@code tanOf("angle", DEGREES)} as shortcut for
- *
+ *
*
* { $tan : { $degreesToRadians : "$angle" } }
*
- *
+ *
* .
*
* @param fieldReference the name of the {@link Field field} that resolves to a numeric value.
* @return new instance of {@link Tan}.
*/
public static Tan tanOf(String fieldReference) {
- return tanOf(fieldReference, AngularDimension.RADIANS);
+ return tanOf(fieldReference, AngularUnit.RADIANS);
}
/**
* Creates a new {@link AggregationExpression} that calculates the tangent of a value that is measured in the given
- * {@link AngularDimension unit}.
+ * {@link AngularUnit unit}.
*
* @param fieldReference the name of the {@link Field field} that resolves to a numeric value.
* @param unit the unit of measure used by the value of the given field.
* @return new instance of {@link Tan}.
*/
- public static Tan tanOf(String fieldReference, AngularDimension unit) {
+ public static Tan tanOf(String fieldReference, AngularUnit unit) {
return tan(Fields.field(fieldReference), unit);
}
/**
* Creates a new {@link AggregationExpression} that calculates the tangent of a value that is measured in
- * {@link AngularDimension#RADIANS}.
+ * {@link AngularUnit#RADIANS}.
*
* @param expression the {@link AggregationExpression expression} that resolves to a numeric value.
* @return new instance of {@link Tan}.
*/
public static Tan tanOf(AggregationExpression expression) {
- return tanOf(expression, AngularDimension.RADIANS);
+ return tanOf(expression, AngularUnit.RADIANS);
}
/**
* Creates a new {@link AggregationExpression} that calculates the tangent of a value that is measured in the given
- * {@link AngularDimension unit}.
+ * {@link AngularUnit unit}.
*
* @param expression the {@link AggregationExpression expression} that resolves to a numeric value.
* @param unit the unit of measure used by the value of the given field.
* @return new instance of {@link Tan}.
*/
- public static Tan tanOf(AggregationExpression expression, AngularDimension unit) {
+ public static Tan tanOf(AggregationExpression expression, AngularUnit unit) {
return tan(expression, unit);
}
/**
* Creates a new {@link AggregationExpression} that calculates the tangent of a value that is measured in
- * {@link AngularDimension#RADIANS}.
+ * {@link AngularUnit#RADIANS}.
*
* @param value anything ({@link Field field}, {@link AggregationExpression expression}, ...) that resolves to a
* numeric value
* @return new instance of {@link Tan}.
*/
public static Tan tan(Object value) {
- return tan(value, AngularDimension.RADIANS);
+ return tan(value, AngularUnit.RADIANS);
}
/**
* Creates a new {@link AggregationExpression} that calculates the tangent of a value that is measured in the given
- * {@link AngularDimension unit}.
+ * {@link AngularUnit unit}.
*
* @param value anything ({@link Field field}, {@link AggregationExpression expression}, ...) that resolves to a
* numeric value.
* @param unit the unit of measure used by the value of the given field.
* @return new instance of {@link Tan}.
*/
- public static Tan tan(Object value, AngularDimension unit) {
+ public static Tan tan(Object value, AngularUnit unit) {
- if (ObjectUtils.nullSafeEquals(AngularDimension.DEGREES, unit)) {
+ if (ObjectUtils.nullSafeEquals(AngularUnit.DEGREES, unit)) {
return new Tan(ConvertOperators.DegreesToRadians.degreesToRadians(value));
}
return new Tan(value);
@@ -2553,7 +2569,7 @@ public class ArithmeticOperators {
/**
* An {@link AggregationExpression expression} that calculates the hyperbolic tangent of a value that is measured in
- * {@link AngularDimension#RADIANS}.
+ * {@link AngularUnit#RADIANS}.
*
* @author Christoph Strobl
* @since 3.3
@@ -2566,38 +2582,38 @@ public class ArithmeticOperators {
/**
* Creates a new {@link AggregationExpression} that calculates the hyperbolic tangent of a value that is measured in
- * {@link AngularDimension#RADIANS}.
+ * {@link AngularUnit#RADIANS}.
*
* @param fieldReference the name of the {@link Field field} that resolves to a numeric value.
* @return new instance of {@link Tanh}.
*/
public static Tanh tanhOf(String fieldReference) {
- return tanhOf(fieldReference, AngularDimension.RADIANS);
+ return tanhOf(fieldReference, AngularUnit.RADIANS);
}
/**
* Creates a new {@link AggregationExpression} that calculates the hyperbolic tangent of a value that is measured in
- * the given {@link AngularDimension unit}.
+ * the given {@link AngularUnit unit}.
*
* Use {@code tanhOf("angle", DEGREES)} as shortcut for
- *
+ *
*
* { $tanh : { $degreesToRadians : "$angle" } }
*
- *
+ *
* .
*
* @param fieldReference the name of the {@link Field field} that resolves to a numeric value.
* @param unit the unit of measure used by the value of the given field.
* @return new instance of {@link Tanh}.
*/
- public static Tanh tanhOf(String fieldReference, AngularDimension unit) {
+ public static Tanh tanhOf(String fieldReference, AngularUnit unit) {
return tanh(Fields.field(fieldReference), unit);
}
/**
* Creates a new {@link AggregationExpression} that calculates the hyperbolic tangent of a value that is measured in
- * {@link AngularDimension#RADIANS}.
+ * {@link AngularUnit#RADIANS}.
*
* Use {@code sinhOf("angle", DEGREES)} as shortcut for eg.
* {@code sinhOf(ConvertOperators.valueOf("angle").degreesToRadians())}.
@@ -2606,45 +2622,45 @@ public class ArithmeticOperators {
* @return new instance of {@link Tanh}.
*/
public static Tanh tanhOf(AggregationExpression expression) {
- return tanhOf(expression, AngularDimension.RADIANS);
+ return tanhOf(expression, AngularUnit.RADIANS);
}
/**
* Creates a new {@link AggregationExpression} that calculates the hyperbolic tangent of a value that is measured in
- * the given {@link AngularDimension unit}.
+ * the given {@link AngularUnit unit}.
*
* @param expression the {@link AggregationExpression expression} that resolves to a numeric value.
* @param unit the unit of measure used by the value of the given field.
* @return new instance of {@link Tanh}.
*/
- public static Tanh tanhOf(AggregationExpression expression, AngularDimension unit) {
+ public static Tanh tanhOf(AggregationExpression expression, AngularUnit unit) {
return tanh(expression, unit);
}
/**
* Creates a new {@link AggregationExpression} that calculates the hyperbolic tangent of a value that is measured in
- * {@link AngularDimension#RADIANS}.
+ * {@link AngularUnit#RADIANS}.
*
* @param value anything ({@link Field field}, {@link AggregationExpression expression}, ...) that resolves to a
* numeric value.
* @return new instance of {@link Tanh}.
*/
public static Tanh tanh(Object value) {
- return tanh(value, AngularDimension.RADIANS);
+ return tanh(value, AngularUnit.RADIANS);
}
/**
* Creates a new {@link AggregationExpression} that calculates the hyperbolic tangent of a value that is measured in
- * the given {@link AngularDimension unit}.
+ * the given {@link AngularUnit unit}.
*
* @param value anything ({@link Field field}, {@link AggregationExpression expression}, ...) that resolves to a
* numeric value
* @param unit the unit of measure used by the value of the given field.
* @return new instance of {@link Tanh}.
*/
- public static Tanh tanh(Object value, AngularDimension unit) {
+ public static Tanh tanh(Object value, AngularUnit unit) {
- if (ObjectUtils.nullSafeEquals(AngularDimension.DEGREES, unit)) {
+ if (ObjectUtils.nullSafeEquals(AngularUnit.DEGREES, unit)) {
return new Tanh(ConvertOperators.DegreesToRadians.degreesToRadians(value));
}
return new Tanh(value);
diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/aggregation/ConvertOperators.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/aggregation/ConvertOperators.java
index b34933444..637ebd8d8 100644
--- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/aggregation/ConvertOperators.java
+++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/aggregation/ConvertOperators.java
@@ -232,7 +232,8 @@ public class ConvertOperators {
}
/**
- * {@link AggregationExpression} for {@code $degreesToRadians} that converts an input value measured in degrees to radians.\
+ * {@link AggregationExpression} for {@code $degreesToRadians} that converts an input value measured in degrees to
+ * radians.
*
* @return new instance of {@link DegreesToRadians}.
* @since 3.3
diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/ArithmeticOperatorsUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/ArithmeticOperatorsUnitTests.java
index 55d164756..7cde7cd1c 100644
--- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/ArithmeticOperatorsUnitTests.java
+++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/ArithmeticOperatorsUnitTests.java
@@ -86,84 +86,84 @@ class ArithmeticOperatorsUnitTests {
void rendersSin() {
assertThat(valueOf("angle").sin().toDocument(Aggregation.DEFAULT_CONTEXT))
- .isEqualTo(Document.parse("{ $sin : \"$angle\" }"));
+ .isEqualTo("{ $sin : \"$angle\" }");
}
@Test // GH-3728
void rendersSinWithValueInDegrees() {
- assertThat(valueOf("angle").sin(AngularDimension.DEGREES).toDocument(Aggregation.DEFAULT_CONTEXT))
- .isEqualTo(Document.parse("{ $sin : { $degreesToRadians : \"$angle\" } }"));
+ assertThat(valueOf("angle").sin(AngularUnit.DEGREES).toDocument(Aggregation.DEFAULT_CONTEXT))
+ .isEqualTo("{ $sin : { $degreesToRadians : \"$angle\" } }");
}
@Test // GH-3728
void rendersSinh() {
assertThat(valueOf("angle").sinh().toDocument(Aggregation.DEFAULT_CONTEXT))
- .isEqualTo(Document.parse("{ $sinh : \"$angle\" }"));
+ .isEqualTo("{ $sinh : \"$angle\" }");
}
@Test // GH-3728
void rendersSinhWithValueInDegrees() {
- assertThat(valueOf("angle").sinh(AngularDimension.DEGREES).toDocument(Aggregation.DEFAULT_CONTEXT))
- .isEqualTo(Document.parse("{ $sinh : { $degreesToRadians : \"$angle\" } }"));
+ assertThat(valueOf("angle").sinh(AngularUnit.DEGREES).toDocument(Aggregation.DEFAULT_CONTEXT))
+ .isEqualTo("{ $sinh : { $degreesToRadians : \"$angle\" } }");
}
@Test // GH-3710
void rendersCos() {
assertThat(valueOf("angle").cos().toDocument(Aggregation.DEFAULT_CONTEXT))
- .isEqualTo(Document.parse("{ $cos : \"$angle\" }"));
+ .isEqualTo("{ $cos : \"$angle\" }");
}
@Test // GH-3710
void rendersCosWithValueInDegrees() {
- assertThat(valueOf("angle").cos(AngularDimension.DEGREES).toDocument(Aggregation.DEFAULT_CONTEXT))
- .isEqualTo(Document.parse("{ $cos : { $degreesToRadians : \"$angle\" } }"));
+ assertThat(valueOf("angle").cos(AngularUnit.DEGREES).toDocument(Aggregation.DEFAULT_CONTEXT))
+ .isEqualTo("{ $cos : { $degreesToRadians : \"$angle\" } }");
}
@Test // GH-3710
void rendersCosh() {
assertThat(valueOf("angle").cosh().toDocument(Aggregation.DEFAULT_CONTEXT))
- .isEqualTo(Document.parse("{ $cosh : \"$angle\" }"));
+ .isEqualTo("{ $cosh : \"$angle\" }");
}
@Test // GH-3710
void rendersCoshWithValueInDegrees() {
- assertThat(valueOf("angle").cosh(AngularDimension.DEGREES).toDocument(Aggregation.DEFAULT_CONTEXT))
- .isEqualTo(Document.parse("{ $cosh : { $degreesToRadians : \"$angle\" } }"));
+ assertThat(valueOf("angle").cosh(AngularUnit.DEGREES).toDocument(Aggregation.DEFAULT_CONTEXT))
+ .isEqualTo("{ $cosh : { $degreesToRadians : \"$angle\" } }");
}
@Test // GH-3730
void rendersTan() {
assertThat(valueOf("angle").tan().toDocument(Aggregation.DEFAULT_CONTEXT))
- .isEqualTo(Document.parse("{ $tan : \"$angle\" }"));
+ .isEqualTo("{ $tan : \"$angle\" }");
}
@Test // GH-3730
void rendersTanWithValueInDegrees() {
- assertThat(valueOf("angle").tan(AngularDimension.DEGREES).toDocument(Aggregation.DEFAULT_CONTEXT))
- .isEqualTo(Document.parse("{ $tan : { $degreesToRadians : \"$angle\" } }"));
+ assertThat(valueOf("angle").tan(AngularUnit.DEGREES).toDocument(Aggregation.DEFAULT_CONTEXT))
+ .isEqualTo("{ $tan : { $degreesToRadians : \"$angle\" } }");
}
@Test // GH-3730
void rendersTanh() {
assertThat(valueOf("angle").tanh().toDocument(Aggregation.DEFAULT_CONTEXT))
- .isEqualTo(Document.parse("{ $tanh : \"$angle\" }"));
+ .isEqualTo("{ $tanh : \"$angle\" }");
}
@Test // GH-3730
void rendersTanhWithValueInDegrees() {
- assertThat(valueOf("angle").tanh(AngularDimension.DEGREES).toDocument(Aggregation.DEFAULT_CONTEXT))
- .isEqualTo(Document.parse("{ $tanh : { $degreesToRadians : \"$angle\" } }"));
+ assertThat(valueOf("angle").tanh(AngularUnit.DEGREES).toDocument(Aggregation.DEFAULT_CONTEXT))
+ .isEqualTo("{ $tanh : { $degreesToRadians : \"$angle\" } }");
}
}
diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/SpelExpressionTransformerUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/SpelExpressionTransformerUnitTests.java
index e30f7f9fb..193ffb520 100644
--- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/SpelExpressionTransformerUnitTests.java
+++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/SpelExpressionTransformerUnitTests.java
@@ -15,7 +15,7 @@
*/
package org.springframework.data.mongodb.core.aggregation;
-import static org.assertj.core.api.Assertions.*;
+import static org.springframework.data.mongodb.test.util.Assertions.*;
import java.util.Arrays;
@@ -53,21 +53,21 @@ public class SpelExpressionTransformerUnitTests {
@Test // DATAMONGO-774
void shouldRenderConstantExpression() {
- assertThat(transform("1")).isEqualTo("1");
- assertThat(transform("-1")).isEqualTo("-1");
- assertThat(transform("1.0")).isEqualTo("1.0");
- assertThat(transform("-1.0")).isEqualTo("-1.0");
- assertThat(transform("null")).isNull();
+ assertThat(transformValue("1")).isEqualTo("1");
+ assertThat(transformValue("-1")).isEqualTo("-1");
+ assertThat(transformValue("1.0")).isEqualTo("1.0");
+ assertThat(transformValue("-1.0")).isEqualTo("-1.0");
+ assertThat(transformValue("null")).isNull();
}
@Test // DATAMONGO-774
void shouldSupportKnownOperands() {
- assertThat(transform("a + b")).isEqualTo(Document.parse("{ \"$add\" : [ \"$a\" , \"$b\"]}"));
- assertThat(transform("a - b")).isEqualTo(Document.parse("{ \"$subtract\" : [ \"$a\" , \"$b\"]}"));
- assertThat(transform("a * b")).isEqualTo(Document.parse("{ \"$multiply\" : [ \"$a\" , \"$b\"]}"));
- assertThat(transform("a / b")).isEqualTo(Document.parse("{ \"$divide\" : [ \"$a\" , \"$b\"]}"));
- assertThat(transform("a % b")).isEqualTo(Document.parse("{ \"$mod\" : [ \"$a\" , \"$b\"]}"));
+ assertThat(transform("a + b")).isEqualTo("{ \"$add\" : [ \"$a\" , \"$b\"]}");
+ assertThat(transform("a - b")).isEqualTo("{ \"$subtract\" : [ \"$a\" , \"$b\"]}");
+ assertThat(transform("a * b")).isEqualTo("{ \"$multiply\" : [ \"$a\" , \"$b\"]}");
+ assertThat(transform("a / b")).isEqualTo("{ \"$divide\" : [ \"$a\" , \"$b\"]}");
+ assertThat(transform("a % b")).isEqualTo("{ \"$mod\" : [ \"$a\" , \"$b\"]}");
}
@Test // DATAMONGO-774
@@ -77,35 +77,35 @@ public class SpelExpressionTransformerUnitTests {
@Test // DATAMONGO-774
void shouldRenderSumExpression() {
- assertThat(transform("a + 1")).isEqualTo(Document.parse("{ \"$add\" : [ \"$a\" , 1]}"));
+ assertThat(transform("a + 1")).isEqualTo("{ \"$add\" : [ \"$a\" , 1]}");
}
@Test // DATAMONGO-774
void shouldRenderFormula() {
- assertThat(transform("(netPrice + surCharge) * taxrate + 42")).isEqualTo(Document.parse(
- "{ \"$add\" : [ { \"$multiply\" : [ { \"$add\" : [ \"$netPrice\" , \"$surCharge\"]} , \"$taxrate\"]} , 42]}"));
+ assertThat(transform("(netPrice + surCharge) * taxrate + 42")).isEqualTo(
+ "{ \"$add\" : [ { \"$multiply\" : [ { \"$add\" : [ \"$netPrice\" , \"$surCharge\"]} , \"$taxrate\"]} , 42]}");
}
@Test // DATAMONGO-774
void shouldRenderFormulaInCurlyBrackets() {
- assertThat(transform("{(netPrice + surCharge) * taxrate + 42}")).isEqualTo(Document.parse(
- "{ \"$add\" : [ { \"$multiply\" : [ { \"$add\" : [ \"$netPrice\" , \"$surCharge\"]} , \"$taxrate\"]} , 42]}"));
+ assertThat(transform("{(netPrice + surCharge) * taxrate + 42}")).isEqualTo(
+ "{ \"$add\" : [ { \"$multiply\" : [ { \"$add\" : [ \"$netPrice\" , \"$surCharge\"]} , \"$taxrate\"]} , 42]}");
}
@Test // DATAMONGO-774
void shouldRenderFieldReference() {
- assertThat(transform("foo")).isEqualTo("$foo");
- assertThat(transform("$foo")).isEqualTo("$foo");
+ assertThat(transformValue("foo")).isEqualTo("$foo");
+ assertThat(transformValue("$foo")).isEqualTo("$foo");
}
@Test // DATAMONGO-774
void shouldRenderNestedFieldReference() {
- assertThat(transform("foo.bar")).isEqualTo("$foo.bar");
- assertThat(transform("$foo.bar")).isEqualTo("$foo.bar");
+ assertThat(transformValue("foo.bar")).isEqualTo("$foo.bar");
+ assertThat(transformValue("$foo.bar")).isEqualTo("$foo.bar");
}
@Test // DATAMONGO-774
@@ -113,52 +113,52 @@ public class SpelExpressionTransformerUnitTests {
void shouldRenderNestedIndexedFieldReference() {
// TODO add support for rendering nested indexed field references
- assertThat(transform("foo[3].bar")).isEqualTo("$foo[3].bar");
+ assertThat(transformValue("foo[3].bar")).isEqualTo("$foo[3].bar");
}
@Test // DATAMONGO-774
void shouldRenderConsecutiveOperation() {
- assertThat(transform("1 + 1 + 1")).isEqualTo(Document.parse("{ \"$add\" : [ 1 , 1 , 1]}"));
+ assertThat(transform("1 + 1 + 1")).isEqualTo("{ \"$add\" : [ 1 , 1 , 1]}");
}
@Test // DATAMONGO-774
void shouldRenderComplexExpression0() {
assertThat(transform("-(1 + q)"))
- .isEqualTo(Document.parse("{ \"$multiply\" : [ -1 , { \"$add\" : [ 1 , \"$q\"]}]}"));
+ .isEqualTo("{ \"$multiply\" : [ -1 , { \"$add\" : [ 1 , \"$q\"]}]}");
}
@Test // DATAMONGO-774
void shouldRenderComplexExpression1() {
- assertThat(transform("1 + (q + 1) / (q - 1)")).isEqualTo(Document.parse(
- "{ \"$add\" : [ 1 , { \"$divide\" : [ { \"$add\" : [ \"$q\" , 1]} , { \"$subtract\" : [ \"$q\" , 1]}]}]}"));
+ assertThat(transform("1 + (q + 1) / (q - 1)")).isEqualTo(
+ "{ \"$add\" : [ 1 , { \"$divide\" : [ { \"$add\" : [ \"$q\" , 1]} , { \"$subtract\" : [ \"$q\" , 1]}]}]}");
}
@Test // DATAMONGO-774
void shouldRenderComplexExpression2() {
- assertThat(transform("(q + 1 + 4 - 5) / (q + 1 + 3 + 4)")).isEqualTo(Document.parse(
- "{ \"$divide\" : [ { \"$subtract\" : [ { \"$add\" : [ \"$q\" , 1 , 4]} , 5]} , { \"$add\" : [ \"$q\" , 1 , 3 , 4]}]}"));
+ assertThat(transform("(q + 1 + 4 - 5) / (q + 1 + 3 + 4)")).isEqualTo(
+ "{ \"$divide\" : [ { \"$subtract\" : [ { \"$add\" : [ \"$q\" , 1 , 4]} , 5]} , { \"$add\" : [ \"$q\" , 1 , 3 , 4]}]}");
}
@Test // DATAMONGO-774
void shouldRenderBinaryExpressionWithMixedSignsCorrectly() {
- assertThat(transform("-4 + 1")).isEqualTo(Document.parse("{ \"$add\" : [ -4 , 1]}"));
- assertThat(transform("1 + -4")).isEqualTo(Document.parse("{ \"$add\" : [ 1 , -4]}"));
+ assertThat(transform("-4 + 1")).isEqualTo("{ \"$add\" : [ -4 , 1]}");
+ assertThat(transform("1 + -4")).isEqualTo("{ \"$add\" : [ 1 , -4]}");
}
@Test // DATAMONGO-774
void shouldRenderConsecutiveOperationsInComplexExpression() {
assertThat(transform("1 + 1 + (1 + 1 + 1) / q"))
- .isEqualTo(Document.parse("{ \"$add\" : [ 1 , 1 , { \"$divide\" : [ { \"$add\" : [ 1 , 1 , 1]} , \"$q\"]}]}"));
+ .isEqualTo("{ \"$add\" : [ 1 , 1 , { \"$divide\" : [ { \"$add\" : [ 1 , 1 , 1]} , \"$q\"]}]}");
}
@Test // DATAMONGO-774
void shouldRenderParameterExpressionResults() {
- assertThat(transform("[0] + [1] + [2]", 1, 2, 3)).isEqualTo(Document.parse("{ \"$add\" : [ 1 , 2 , 3]}"));
+ assertThat(transform("[0] + [1] + [2]", 1, 2, 3)).isEqualTo("{ \"$add\" : [ 1 , 2 , 3]}");
}
@Test // DATAMONGO-774
@@ -189,852 +189,856 @@ public class SpelExpressionTransformerUnitTests {
Person person = new Person();
person.setAge(10);
- assertThat(transform("[0].age + a.c", person)).isEqualTo(Document.parse("{ \"$add\" : [ 10 , \"$a.c\"] }"));
+ assertThat(transform("[0].age + a.c", person)).isEqualTo("{ \"$add\" : [ 10 , \"$a.c\"] }");
}
@Test // DATAMONGO-840
void shouldRenderCompoundExpressionsWithOnlyFieldReferences() {
- assertThat(transform("a.b + a.c")).isEqualTo(Document.parse("{ \"$add\" : [ \"$a.b\" , \"$a.c\"]}"));
+ assertThat(transform("a.b + a.c")).isEqualTo("{ \"$add\" : [ \"$a.b\" , \"$a.c\"]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceNodeAnd() {
- assertThat(transform("and(a, b)")).isEqualTo(Document.parse("{ \"$and\" : [ \"$a\" , \"$b\"]}"));
+ assertThat(transform("and(a, b)")).isEqualTo("{ \"$and\" : [ \"$a\" , \"$b\"]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceNodeOr() {
- assertThat(transform("or(a, b)")).isEqualTo(Document.parse("{ \"$or\" : [ \"$a\" , \"$b\"]}"));
+ assertThat(transform("or(a, b)")).isEqualTo("{ \"$or\" : [ \"$a\" , \"$b\"]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceNodeNot() {
- assertThat(transform("not(a)")).isEqualTo(Document.parse("{ \"$not\" : [ \"$a\"]}"));
+ assertThat(transform("not(a)")).isEqualTo("{ \"$not\" : [ \"$a\"]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceNodeSetEquals() {
- assertThat(transform("setEquals(a, b)")).isEqualTo(Document.parse("{ \"$setEquals\" : [ \"$a\" , \"$b\"]}"));
+ assertThat(transform("setEquals(a, b)")).isEqualTo("{ \"$setEquals\" : [ \"$a\" , \"$b\"]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceNodeSetEqualsForArrays() {
assertThat(transform("setEquals(new int[]{1,2,3}, new int[]{4,5,6})"))
- .isEqualTo(Document.parse("{ \"$setEquals\" : [ [ 1 , 2 , 3] , [ 4 , 5 , 6]]}"));
+ .isEqualTo("{ \"$setEquals\" : [ [ 1 , 2 , 3] , [ 4 , 5 , 6]]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceNodeSetEqualsMixedArrays() {
assertThat(transform("setEquals(a, new int[]{4,5,6})"))
- .isEqualTo(Document.parse("{ \"$setEquals\" : [ \"$a\" , [ 4 , 5 , 6]]}"));
+ .isEqualTo("{ \"$setEquals\" : [ \"$a\" , [ 4 , 5 , 6]]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceSetIntersection() {
assertThat(transform("setIntersection(a, new int[]{4,5,6})"))
- .isEqualTo(Document.parse("{ \"$setIntersection\" : [ \"$a\" , [ 4 , 5 , 6]]}"));
+ .isEqualTo("{ \"$setIntersection\" : [ \"$a\" , [ 4 , 5 , 6]]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceSetUnion() {
assertThat(transform("setUnion(a, new int[]{4,5,6})"))
- .isEqualTo(Document.parse("{ \"$setUnion\" : [ \"$a\" , [ 4 , 5 , 6]]}"));
+ .isEqualTo("{ \"$setUnion\" : [ \"$a\" , [ 4 , 5 , 6]]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceSeDifference() {
assertThat(transform("setDifference(a, new int[]{4,5,6})"))
- .isEqualTo(Document.parse("{ \"$setDifference\" : [ \"$a\" , [ 4 , 5 , 6]]}"));
+ .isEqualTo("{ \"$setDifference\" : [ \"$a\" , [ 4 , 5 , 6]]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceSetIsSubset() {
assertThat(transform("setIsSubset(a, new int[]{4,5,6})"))
- .isEqualTo(Document.parse("{ \"$setIsSubset\" : [ \"$a\" , [ 4 , 5 , 6]]}"));
+ .isEqualTo("{ \"$setIsSubset\" : [ \"$a\" , [ 4 , 5 , 6]]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceAnyElementTrue() {
- assertThat(transform("anyElementTrue(a)")).isEqualTo(Document.parse("{ \"$anyElementTrue\" : [ \"$a\"]}"));
+ assertThat(transform("anyElementTrue(a)")).isEqualTo("{ \"$anyElementTrue\" : [ \"$a\"]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceAllElementsTrue() {
assertThat(transform("allElementsTrue(a, new int[]{4,5,6})"))
- .isEqualTo(Document.parse("{ \"$allElementsTrue\" : [ \"$a\" , [ 4 , 5 , 6]]}"));
+ .isEqualTo("{ \"$allElementsTrue\" : [ \"$a\" , [ 4 , 5 , 6]]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceCmp() {
- assertThat(transform("cmp(a, 250)")).isEqualTo(Document.parse("{ \"$cmp\" : [ \"$a\" , 250]}"));
+ assertThat(transform("cmp(a, 250)")).isEqualTo("{ \"$cmp\" : [ \"$a\" , 250]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceEq() {
- assertThat(transform("eq(a, 250)")).isEqualTo(Document.parse("{ \"$eq\" : [ \"$a\" , 250]}"));
+ assertThat(transform("eq(a, 250)")).isEqualTo("{ \"$eq\" : [ \"$a\" , 250]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceGt() {
- assertThat(transform("gt(a, 250)")).isEqualTo(Document.parse("{ \"$gt\" : [ \"$a\" , 250]}"));
+ assertThat(transform("gt(a, 250)")).isEqualTo("{ \"$gt\" : [ \"$a\" , 250]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceGte() {
- assertThat(transform("gte(a, 250)")).isEqualTo(Document.parse("{ \"$gte\" : [ \"$a\" , 250]}"));
+ assertThat(transform("gte(a, 250)")).isEqualTo("{ \"$gte\" : [ \"$a\" , 250]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceLt() {
- assertThat(transform("lt(a, 250)")).isEqualTo(Document.parse("{ \"$lt\" : [ \"$a\" , 250]}"));
+ assertThat(transform("lt(a, 250)")).isEqualTo("{ \"$lt\" : [ \"$a\" , 250]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceLte() {
- assertThat(transform("lte(a, 250)")).isEqualTo(Document.parse("{ \"$lte\" : [ \"$a\" , 250]}"));
+ assertThat(transform("lte(a, 250)")).isEqualTo("{ \"$lte\" : [ \"$a\" , 250]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceNe() {
- assertThat(transform("ne(a, 250)")).isEqualTo(Document.parse("{ \"$ne\" : [ \"$a\" , 250]}"));
+ assertThat(transform("ne(a, 250)")).isEqualTo("{ \"$ne\" : [ \"$a\" , 250]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceAbs() {
- assertThat(transform("abs(1)")).isEqualTo(Document.parse("{ \"$abs\" : 1}"));
+ assertThat(transform("abs(1)")).isEqualTo("{ \"$abs\" : 1}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceAdd() {
- assertThat(transform("add(a, 250)")).isEqualTo(Document.parse("{ \"$add\" : [ \"$a\" , 250]}"));
+ assertThat(transform("add(a, 250)")).isEqualTo("{ \"$add\" : [ \"$a\" , 250]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceCeil() {
- assertThat(transform("ceil(7.8)")).isEqualTo(Document.parse("{ \"$ceil\" : 7.8}"));
+ assertThat(transform("ceil(7.8)")).isEqualTo("{ \"$ceil\" : 7.8}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceDivide() {
- assertThat(transform("divide(a, 250)")).isEqualTo(Document.parse("{ \"$divide\" : [ \"$a\" , 250]}"));
+ assertThat(transform("divide(a, 250)")).isEqualTo("{ \"$divide\" : [ \"$a\" , 250]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceExp() {
- assertThat(transform("exp(2)")).isEqualTo(Document.parse("{ \"$exp\" : 2}"));
+ assertThat(transform("exp(2)")).isEqualTo("{ \"$exp\" : 2}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceFloor() {
- assertThat(transform("floor(2)")).isEqualTo(Document.parse("{ \"$floor\" : 2}"));
+ assertThat(transform("floor(2)")).isEqualTo("{ \"$floor\" : 2}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceLn() {
- assertThat(transform("ln(2)")).isEqualTo(Document.parse("{ \"$ln\" : 2}"));
+ assertThat(transform("ln(2)")).isEqualTo("{ \"$ln\" : 2}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceLog() {
- assertThat(transform("log(100, 10)")).isEqualTo(Document.parse("{ \"$log\" : [ 100 , 10]}"));
+ assertThat(transform("log(100, 10)")).isEqualTo("{ \"$log\" : [ 100 , 10]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceLog10() {
- assertThat(transform("log10(100)")).isEqualTo(Document.parse("{ \"$log10\" : 100}"));
+ assertThat(transform("log10(100)")).isEqualTo("{ \"$log10\" : 100}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceNodeMod() {
- assertThat(transform("mod(a, b)")).isEqualTo(Document.parse("{ \"$mod\" : [ \"$a\" , \"$b\"]}"));
+ assertThat(transform("mod(a, b)")).isEqualTo("{ \"$mod\" : [ \"$a\" , \"$b\"]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceNodeMultiply() {
- assertThat(transform("multiply(a, b)")).isEqualTo(Document.parse("{ \"$multiply\" : [ \"$a\" , \"$b\"]}"));
+ assertThat(transform("multiply(a, b)")).isEqualTo("{ \"$multiply\" : [ \"$a\" , \"$b\"]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceNodePow() {
- assertThat(transform("pow(a, 2)")).isEqualTo(Document.parse("{ \"$pow\" : [ \"$a\" , 2]}"));
+ assertThat(transform("pow(a, 2)")).isEqualTo("{ \"$pow\" : [ \"$a\" , 2]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceSqrt() {
- assertThat(transform("sqrt(2)")).isEqualTo(Document.parse("{ \"$sqrt\" : 2}"));
+ assertThat(transform("sqrt(2)")).isEqualTo("{ \"$sqrt\" : 2}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceNodeSubtract() {
- assertThat(transform("subtract(a, b)")).isEqualTo(Document.parse("{ \"$subtract\" : [ \"$a\" , \"$b\"]}"));
+ assertThat(transform("subtract(a, b)")).isEqualTo("{ \"$subtract\" : [ \"$a\" , \"$b\"]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceTrunc() {
- assertThat(transform("trunc(2.1)")).isEqualTo(Document.parse("{ \"$trunc\" : 2.1}"));
+ assertThat(transform("trunc(2.1)")).isEqualTo("{ \"$trunc\" : 2.1}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceNodeConcat() {
- assertThat(transform("concat(a, b, 'c')")).isEqualTo(Document.parse("{ \"$concat\" : [ \"$a\" , \"$b\" , \"c\"]}"));
+ assertThat(transform("concat(a, b, 'c')")).isEqualTo("{ \"$concat\" : [ \"$a\" , \"$b\" , \"c\"]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceNodeSubstrc() {
- assertThat(transform("substr(a, 0, 1)")).isEqualTo(Document.parse("{ \"$substr\" : [ \"$a\" , 0 , 1]}"));
+ assertThat(transform("substr(a, 0, 1)")).isEqualTo("{ \"$substr\" : [ \"$a\" , 0 , 1]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceToLower() {
- assertThat(transform("toLower(a)")).isEqualTo(Document.parse("{ \"$toLower\" : \"$a\"}"));
+ assertThat(transform("toLower(a)")).isEqualTo("{ \"$toLower\" : \"$a\"}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceToUpper() {
- assertThat(transform("toUpper(a)")).isEqualTo(Document.parse("{ \"$toUpper\" : \"$a\"}"));
+ assertThat(transform("toUpper(a)")).isEqualTo("{ \"$toUpper\" : \"$a\"}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceNodeStrCaseCmp() {
- assertThat(transform("strcasecmp(a, b)")).isEqualTo(Document.parse("{ \"$strcasecmp\" : [ \"$a\" , \"$b\"]}"));
+ assertThat(transform("strcasecmp(a, b)")).isEqualTo("{ \"$strcasecmp\" : [ \"$a\" , \"$b\"]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceMeta() {
- assertThat(transform("meta('textScore')")).isEqualTo(Document.parse("{ \"$meta\" : \"textScore\"}"));
+ assertThat(transform("meta('textScore')")).isEqualTo("{ \"$meta\" : \"textScore\"}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceNodeArrayElemAt() {
- assertThat(transform("arrayElemAt(a, 10)")).isEqualTo(Document.parse("{ \"$arrayElemAt\" : [ \"$a\" , 10]}"));
+ assertThat(transform("arrayElemAt(a, 10)")).isEqualTo("{ \"$arrayElemAt\" : [ \"$a\" , 10]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceNodeConcatArrays() {
assertThat(transform("concatArrays(a, b, c)"))
- .isEqualTo(Document.parse("{ \"$concatArrays\" : [ \"$a\" , \"$b\" , \"$c\"]}"));
+ .isEqualTo("{ \"$concatArrays\" : [ \"$a\" , \"$b\" , \"$c\"]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceNodeFilter() {
- assertThat(transform("filter(a, 'num', '$$num' > 10)")).isEqualTo(Document.parse(
- "{ \"$filter\" : { \"input\" : \"$a\" , \"as\" : \"num\" , \"cond\" : { \"$gt\" : [ \"$$num\" , 10]}}}"));
+ assertThat(transform("filter(a, 'num', '$$num' > 10)")).isEqualTo(
+ "{ \"$filter\" : { \"input\" : \"$a\" , \"as\" : \"num\" , \"cond\" : { \"$gt\" : [ \"$$num\" , 10]}}}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceIsArray() {
- assertThat(transform("isArray(a)")).isEqualTo(Document.parse("{ \"$isArray\" : \"$a\"}"));
+ assertThat(transform("isArray(a)")).isEqualTo("{ \"$isArray\" : \"$a\"}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceIsSize() {
- assertThat(transform("size(a)")).isEqualTo(Document.parse("{ \"$size\" : \"$a\"}"));
+ assertThat(transform("size(a)")).isEqualTo("{ \"$size\" : \"$a\"}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceNodeSlice() {
- assertThat(transform("slice(a, 10)")).isEqualTo(Document.parse("{ \"$slice\" : [ \"$a\" , 10]}"));
+ assertThat(transform("slice(a, 10)")).isEqualTo("{ \"$slice\" : [ \"$a\" , 10]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceNodeMap() {
- assertThat(transform("map(quizzes, 'grade', '$$grade' + 2)")).isEqualTo(Document.parse(
- "{ \"$map\" : { \"input\" : \"$quizzes\" , \"as\" : \"grade\" , \"in\" : { \"$add\" : [ \"$$grade\" , 2]}}}"));
+ assertThat(transform("map(quizzes, 'grade', '$$grade' + 2)")).isEqualTo(
+ "{ \"$map\" : { \"input\" : \"$quizzes\" , \"as\" : \"grade\" , \"in\" : { \"$add\" : [ \"$$grade\" , 2]}}}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceNodeLet() {
- assertThat(transform("let({low:1, high:'$$low'}, gt('$$low', '$$high'))")).isEqualTo(Document.parse(
- "{ \"$let\" : { \"vars\" : { \"low\" : 1 , \"high\" : \"$$low\"} , \"in\" : { \"$gt\" : [ \"$$low\" , \"$$high\"]}}}"));
+ assertThat(transform("let({low:1, high:'$$low'}, gt('$$low', '$$high'))")).isEqualTo(
+ "{ \"$let\" : { \"vars\" : { \"low\" : 1 , \"high\" : \"$$low\"} , \"in\" : { \"$gt\" : [ \"$$low\" , \"$$high\"]}}}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceLiteral() {
- assertThat(transform("literal($1)")).isEqualTo(Document.parse("{ \"$literal\" : \"$1\"}"));
+ assertThat(transform("literal($1)")).isEqualTo("{ \"$literal\" : \"$1\"}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceDayOfYear() {
- assertThat(transform("dayOfYear($1)")).isEqualTo(Document.parse("{ \"$dayOfYear\" : \"$1\"}"));
+ assertThat(transform("dayOfYear($1)")).isEqualTo("{ \"$dayOfYear\" : \"$1\"}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceDayOfMonth() {
- assertThat(transform("dayOfMonth($1)")).isEqualTo(Document.parse("{ \"$dayOfMonth\" : \"$1\"}"));
+ assertThat(transform("dayOfMonth($1)")).isEqualTo("{ \"$dayOfMonth\" : \"$1\"}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceDayOfWeek() {
- assertThat(transform("dayOfWeek($1)")).isEqualTo(Document.parse("{ \"$dayOfWeek\" : \"$1\"}"));
+ assertThat(transform("dayOfWeek($1)")).isEqualTo("{ \"$dayOfWeek\" : \"$1\"}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceYear() {
- assertThat(transform("year($1)")).isEqualTo(Document.parse("{ \"$year\" : \"$1\"}"));
+ assertThat(transform("year($1)")).isEqualTo("{ \"$year\" : \"$1\"}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceMonth() {
- assertThat(transform("month($1)")).isEqualTo(Document.parse("{ \"$month\" : \"$1\"}"));
+ assertThat(transform("month($1)")).isEqualTo("{ \"$month\" : \"$1\"}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceWeek() {
- assertThat(transform("week($1)")).isEqualTo(Document.parse("{ \"$week\" : \"$1\"}"));
+ assertThat(transform("week($1)")).isEqualTo("{ \"$week\" : \"$1\"}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceHour() {
- assertThat(transform("hour($1)")).isEqualTo(Document.parse("{ \"$hour\" : \"$1\"}"));
+ assertThat(transform("hour($1)")).isEqualTo("{ \"$hour\" : \"$1\"}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceMinute() {
- assertThat(transform("minute($1)")).isEqualTo(Document.parse("{ \"$minute\" : \"$1\"}"));
+ assertThat(transform("minute($1)")).isEqualTo("{ \"$minute\" : \"$1\"}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceSecond() {
- assertThat(transform("second($1)")).isEqualTo(Document.parse("{ \"$second\" : \"$1\"}"));
+ assertThat(transform("second($1)")).isEqualTo("{ \"$second\" : \"$1\"}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceMillisecond() {
- assertThat(transform("millisecond($1)")).isEqualTo(Document.parse("{ \"$millisecond\" : \"$1\"}"));
+ assertThat(transform("millisecond($1)")).isEqualTo("{ \"$millisecond\" : \"$1\"}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceDateToString() {
assertThat(transform("dateToString('%Y-%m-%d', $date)"))
- .isEqualTo(Document.parse("{ \"$dateToString\" : { \"format\" : \"%Y-%m-%d\" , \"date\" : \"$date\"}}"));
+ .isEqualTo("{ \"$dateToString\" : { \"format\" : \"%Y-%m-%d\" , \"date\" : \"$date\"}}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceCond() {
assertThat(transform("cond(qty > 250, 30, 20)")).isEqualTo(
- Document.parse("{ \"$cond\" : { \"if\" : { \"$gt\" : [ \"$qty\" , 250]} , \"then\" : 30 , \"else\" : 20}}"));
+ "{ \"$cond\" : { \"if\" : { \"$gt\" : [ \"$qty\" , 250]} , \"then\" : 30 , \"else\" : 20}}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceNodeIfNull() {
- assertThat(transform("ifNull(a, 10)")).isEqualTo(Document.parse("{ \"$ifNull\" : [ \"$a\" , 10]}"));
+ assertThat(transform("ifNull(a, 10)")).isEqualTo("{ \"$ifNull\" : [ \"$a\" , 10]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceNodeSum() {
- assertThat(transform("sum(a, b)")).isEqualTo(Document.parse("{ \"$sum\" : [ \"$a\" , \"$b\"]}"));
+ assertThat(transform("sum(a, b)")).isEqualTo("{ \"$sum\" : [ \"$a\" , \"$b\"]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceNodeAvg() {
- assertThat(transform("avg(a, b)")).isEqualTo(Document.parse("{ \"$avg\" : [ \"$a\" , \"$b\"]}"));
+ assertThat(transform("avg(a, b)")).isEqualTo("{ \"$avg\" : [ \"$a\" , \"$b\"]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceFirst() {
- assertThat(transform("first($1)")).isEqualTo(Document.parse("{ \"$first\" : \"$1\"}"));
+ assertThat(transform("first($1)")).isEqualTo("{ \"$first\" : \"$1\"}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceLast() {
- assertThat(transform("last($1)")).isEqualTo(Document.parse("{ \"$last\" : \"$1\"}"));
+ assertThat(transform("last($1)")).isEqualTo("{ \"$last\" : \"$1\"}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceNodeMax() {
- assertThat(transform("max(a, b)")).isEqualTo(Document.parse("{ \"$max\" : [ \"$a\" , \"$b\"]}"));
+ assertThat(transform("max(a, b)")).isEqualTo("{ \"$max\" : [ \"$a\" , \"$b\"]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceNodeMin() {
- assertThat(transform("min(a, b)")).isEqualTo(Document.parse("{ \"$min\" : [ \"$a\" , \"$b\"]}"));
+ assertThat(transform("min(a, b)")).isEqualTo("{ \"$min\" : [ \"$a\" , \"$b\"]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceNodePush() {
assertThat(transform("push({'item':'$item', 'quantity':'$qty'})"))
- .isEqualTo(Document.parse("{ \"$push\" : { \"item\" : \"$item\" , \"quantity\" : \"$qty\"}}"));
+ .isEqualTo("{ \"$push\" : { \"item\" : \"$item\" , \"quantity\" : \"$qty\"}}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceAddToSet() {
- assertThat(transform("addToSet($1)")).isEqualTo(Document.parse("{ \"$addToSet\" : \"$1\"}"));
+ assertThat(transform("addToSet($1)")).isEqualTo("{ \"$addToSet\" : \"$1\"}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceNodeStdDevPop() {
assertThat(transform("stdDevPop(scores.score)"))
- .isEqualTo(Document.parse("{ \"$stdDevPop\" : [ \"$scores.score\"]}"));
+ .isEqualTo("{ \"$stdDevPop\" : [ \"$scores.score\"]}");
}
@Test // DATAMONGO-1530
void shouldRenderMethodReferenceNodeStdDevSamp() {
- assertThat(transform("stdDevSamp(age)")).isEqualTo(Document.parse("{ \"$stdDevSamp\" : [ \"$age\"]}"));
+ assertThat(transform("stdDevSamp(age)")).isEqualTo("{ \"$stdDevSamp\" : [ \"$age\"]}");
}
@Test // DATAMONGO-1530
void shouldRenderOperationNodeEq() {
- assertThat(transform("foo == 10")).isEqualTo(Document.parse("{ \"$eq\" : [ \"$foo\" , 10]}"));
+ assertThat(transform("foo == 10")).isEqualTo("{ \"$eq\" : [ \"$foo\" , 10]}");
}
@Test // DATAMONGO-1530
void shouldRenderOperationNodeNe() {
- assertThat(transform("foo != 10")).isEqualTo(Document.parse("{ \"$ne\" : [ \"$foo\" , 10]}"));
+ assertThat(transform("foo != 10")).isEqualTo("{ \"$ne\" : [ \"$foo\" , 10]}");
}
@Test // DATAMONGO-1530
void shouldRenderOperationNodeGt() {
- assertThat(transform("foo > 10")).isEqualTo(Document.parse("{ \"$gt\" : [ \"$foo\" , 10]}"));
+ assertThat(transform("foo > 10")).isEqualTo("{ \"$gt\" : [ \"$foo\" , 10]}");
}
@Test // DATAMONGO-1530
void shouldRenderOperationNodeGte() {
- assertThat(transform("foo >= 10")).isEqualTo(Document.parse("{ \"$gte\" : [ \"$foo\" , 10]}"));
+ assertThat(transform("foo >= 10")).isEqualTo("{ \"$gte\" : [ \"$foo\" , 10]}");
}
@Test // DATAMONGO-1530
void shouldRenderOperationNodeLt() {
- assertThat(transform("foo < 10")).isEqualTo(Document.parse("{ \"$lt\" : [ \"$foo\" , 10]}"));
+ assertThat(transform("foo < 10")).isEqualTo("{ \"$lt\" : [ \"$foo\" , 10]}");
}
@Test // DATAMONGO-1530
void shouldRenderOperationNodeLte() {
- assertThat(transform("foo <= 10")).isEqualTo(Document.parse("{ \"$lte\" : [ \"$foo\" , 10]}"));
+ assertThat(transform("foo <= 10")).isEqualTo("{ \"$lte\" : [ \"$foo\" , 10]}");
}
@Test // DATAMONGO-1530
void shouldRenderOperationNodePow() {
- assertThat(transform("foo^2")).isEqualTo(Document.parse("{ \"$pow\" : [ \"$foo\" , 2]}"));
+ assertThat(transform("foo^2")).isEqualTo("{ \"$pow\" : [ \"$foo\" , 2]}");
}
@Test // DATAMONGO-1530
void shouldRenderOperationNodeOr() {
- assertThat(transform("true || false")).isEqualTo(Document.parse("{ \"$or\" : [ true , false]}"));
+ assertThat(transform("true || false")).isEqualTo("{ \"$or\" : [ true , false]}");
}
@Test // DATAMONGO-1530
void shouldRenderComplexOperationNodeOr() {
assertThat(transform("1+2 || concat(a, b) || true")).isEqualTo(
- Document.parse("{ \"$or\" : [ { \"$add\" : [ 1 , 2]} , { \"$concat\" : [ \"$a\" , \"$b\"]} , true]}"));
+ "{ \"$or\" : [ { \"$add\" : [ 1 , 2]} , { \"$concat\" : [ \"$a\" , \"$b\"]} , true]}");
}
@Test // DATAMONGO-1530
void shouldRenderOperationNodeAnd() {
- assertThat(transform("true && false")).isEqualTo(Document.parse("{ \"$and\" : [ true , false]}"));
+ assertThat(transform("true && false")).isEqualTo("{ \"$and\" : [ true , false]}");
}
@Test // DATAMONGO-1530
void shouldRenderComplexOperationNodeAnd() {
assertThat(transform("1+2 && concat(a, b) && true")).isEqualTo(
- Document.parse("{ \"$and\" : [ { \"$add\" : [ 1 , 2]} , { \"$concat\" : [ \"$a\" , \"$b\"]} , true]}"));
+ "{ \"$and\" : [ { \"$add\" : [ 1 , 2]} , { \"$concat\" : [ \"$a\" , \"$b\"]} , true]}");
}
@Test // DATAMONGO-1530
void shouldRenderNotCorrectly() {
- assertThat(transform("!true")).isEqualTo(Document.parse("{ \"$not\" : [ true]}"));
+ assertThat(transform("!true")).isEqualTo("{ \"$not\" : [ true]}");
}
@Test // DATAMONGO-1530
void shouldRenderComplexNotCorrectly() {
- assertThat(transform("!(foo > 10)")).isEqualTo(Document.parse("{ \"$not\" : [ { \"$gt\" : [ \"$foo\" , 10]}]}"));
+ assertThat(transform("!(foo > 10)")).isEqualTo("{ \"$not\" : [ { \"$gt\" : [ \"$foo\" , 10]}]}");
}
@Test // DATAMONGO-1548
void shouldRenderMethodReferenceIndexOfBytes() {
assertThat(transform("indexOfBytes(item, 'foo')"))
- .isEqualTo(Document.parse("{ \"$indexOfBytes\" : [ \"$item\" , \"foo\"]}"));
+ .isEqualTo("{ \"$indexOfBytes\" : [ \"$item\" , \"foo\"]}");
}
@Test // DATAMONGO-1548
void shouldRenderMethodReferenceIndexOfCP() {
assertThat(transform("indexOfCP(item, 'foo')"))
- .isEqualTo(Document.parse("{ \"$indexOfCP\" : [ \"$item\" , \"foo\"]}"));
+ .isEqualTo("{ \"$indexOfCP\" : [ \"$item\" , \"foo\"]}");
}
@Test // DATAMONGO-1548
void shouldRenderMethodReferenceSplit() {
- assertThat(transform("split(item, ',')")).isEqualTo(Document.parse("{ \"$split\" : [ \"$item\" , \",\"]}"));
+ assertThat(transform("split(item, ',')")).isEqualTo("{ \"$split\" : [ \"$item\" , \",\"]}");
}
@Test // DATAMONGO-1548
void shouldRenderMethodReferenceStrLenBytes() {
- assertThat(transform("strLenBytes(item)")).isEqualTo(Document.parse("{ \"$strLenBytes\" : \"$item\"}"));
+ assertThat(transform("strLenBytes(item)")).isEqualTo("{ \"$strLenBytes\" : \"$item\"}");
}
@Test // DATAMONGO-1548
void shouldRenderMethodReferenceStrLenCP() {
- assertThat(transform("strLenCP(item)")).isEqualTo(Document.parse("{ \"$strLenCP\" : \"$item\"}"));
+ assertThat(transform("strLenCP(item)")).isEqualTo("{ \"$strLenCP\" : \"$item\"}");
}
@Test // DATAMONGO-1548
void shouldRenderMethodSubstrCP() {
- assertThat(transform("substrCP(item, 0, 5)")).isEqualTo(Document.parse("{ \"$substrCP\" : [ \"$item\" , 0 , 5]}"));
+ assertThat(transform("substrCP(item, 0, 5)")).isEqualTo("{ \"$substrCP\" : [ \"$item\" , 0 , 5]}");
}
@Test // DATAMONGO-1548
void shouldRenderMethodReferenceReverseArray() {
- assertThat(transform("reverseArray(array)")).isEqualTo(Document.parse("{ \"$reverseArray\" : \"$array\"}"));
+ assertThat(transform("reverseArray(array)")).isEqualTo("{ \"$reverseArray\" : \"$array\"}");
}
@Test // DATAMONGO-1548
void shouldRenderMethodReferenceReduce() {
- assertThat(transform("reduce(field, '', {'$concat':{'$$value','$$this'}})")).isEqualTo(Document.parse(
- "{ \"$reduce\" : { \"input\" : \"$field\" , \"initialValue\" : \"\" , \"in\" : { \"$concat\" : [ \"$$value\" , \"$$this\"]}}}"));
+ assertThat(transform("reduce(field, '', {'$concat':{'$$value','$$this'}})")).isEqualTo(
+ "{ \"$reduce\" : { \"input\" : \"$field\" , \"initialValue\" : \"\" , \"in\" : { \"$concat\" : [ \"$$value\" , \"$$this\"]}}}");
}
@Test // DATAMONGO-1548
void shouldRenderMethodReferenceZip() {
assertThat(transform("zip(new String[]{'$array1', '$array2'})"))
- .isEqualTo(Document.parse("{ \"$zip\" : { \"inputs\" : [ \"$array1\" , \"$array2\"]}}"));
+ .isEqualTo("{ \"$zip\" : { \"inputs\" : [ \"$array1\" , \"$array2\"]}}");
}
@Test // DATAMONGO-1548
void shouldRenderMethodReferenceZipWithOptionalArgs() {
- assertThat(transform("zip(new String[]{'$array1', '$array2'}, true, new int[]{1,2})")).isEqualTo(Document.parse(
- "{ \"$zip\" : { \"inputs\" : [ \"$array1\" , \"$array2\"] , \"useLongestLength\" : true , \"defaults\" : [ 1 , 2]}}"));
+ assertThat(transform("zip(new String[]{'$array1', '$array2'}, true, new int[]{1,2})")).isEqualTo(
+ "{ \"$zip\" : { \"inputs\" : [ \"$array1\" , \"$array2\"] , \"useLongestLength\" : true , \"defaults\" : [ 1 , 2]}}");
}
@Test // DATAMONGO-1548
void shouldRenderMethodIn() {
- assertThat(transform("in('item', array)")).isEqualTo(Document.parse("{ \"$in\" : [ \"item\" , \"$array\"]}"));
+ assertThat(transform("in('item', array)")).isEqualTo("{ \"$in\" : [ \"item\" , \"$array\"]}");
}
@Test // DATAMONGO-1548
void shouldRenderMethodRefereneIsoDayOfWeek() {
- assertThat(transform("isoDayOfWeek(date)")).isEqualTo(Document.parse("{ \"$isoDayOfWeek\" : \"$date\"}"));
+ assertThat(transform("isoDayOfWeek(date)")).isEqualTo("{ \"$isoDayOfWeek\" : \"$date\"}");
}
@Test // DATAMONGO-1548
void shouldRenderMethodRefereneIsoWeek() {
- assertThat(transform("isoWeek(date)")).isEqualTo(Document.parse("{ \"$isoWeek\" : \"$date\"}"));
+ assertThat(transform("isoWeek(date)")).isEqualTo("{ \"$isoWeek\" : \"$date\"}");
}
@Test // DATAMONGO-1548
void shouldRenderMethodRefereneIsoWeekYear() {
- assertThat(transform("isoWeekYear(date)")).isEqualTo(Document.parse("{ \"$isoWeekYear\" : \"$date\"}"));
+ assertThat(transform("isoWeekYear(date)")).isEqualTo("{ \"$isoWeekYear\" : \"$date\"}");
}
@Test // DATAMONGO-1548
void shouldRenderMethodRefereneType() {
- assertThat(transform("type(a)")).isEqualTo(Document.parse("{ \"$type\" : \"$a\"}"));
+ assertThat(transform("type(a)")).isEqualTo("{ \"$type\" : \"$a\"}");
}
@Test // DATAMONGO-2077
void shouldRenderArrayToObjectWithFieldReference() {
- assertThat(transform("arrayToObject(field)")).isEqualTo(Document.parse("{ \"$arrayToObject\" : \"$field\"}"));
+ assertThat(transform("arrayToObject(field)")).isEqualTo("{ \"$arrayToObject\" : \"$field\"}");
}
@Test // DATAMONGO-2077
void shouldRenderArrayToObjectWithArray() {
assertThat(transform("arrayToObject(new String[]{'key', 'value'})"))
- .isEqualTo(Document.parse("{ \"$arrayToObject\" : [\"key\", \"value\"]}"));
+ .isEqualTo("{ \"$arrayToObject\" : [\"key\", \"value\"]}");
}
@Test // DATAMONGO-2077
void shouldRenderObjectToArrayWithFieldReference() {
- assertThat(transform("objectToArray(field)")).isEqualTo(Document.parse("{ \"$objectToArray\" : \"$field\"}"));
+ assertThat(transform("objectToArray(field)")).isEqualTo("{ \"$objectToArray\" : \"$field\"}");
}
@Test // DATAMONGO-2077
void shouldRenderMergeObjects() {
assertThat(transform("mergeObjects(field1, $$ROOT)"))
- .isEqualTo(Document.parse("{ \"$mergeObjects\" : [\"$field1\", \"$$ROOT\"]}"));
+ .isEqualTo("{ \"$mergeObjects\" : [\"$field1\", \"$$ROOT\"]}");
}
@Test // DATAMONGO-2077
void shouldRenderTrimWithoutChars() {
- assertThat(transform("trim(field)")).isEqualTo(Document.parse("{ \"$trim\" : {\"input\" : \"$field\"}}"));
+ assertThat(transform("trim(field)")).isEqualTo("{ \"$trim\" : {\"input\" : \"$field\"}}");
}
@Test // DATAMONGO-2077
void shouldRenderTrimWithChars() {
assertThat(transform("trim(field, 'ie')"))
- .isEqualTo(Document.parse("{ \"$trim\" : {\"input\" : \"$field\", \"chars\" : \"ie\" }}"));
+ .isEqualTo("{ \"$trim\" : {\"input\" : \"$field\", \"chars\" : \"ie\" }}");
}
@Test // DATAMONGO-2077
void shouldRenderTrimWithCharsFromFieldReference() {
assertThat(transform("trim(field1, field2)"))
- .isEqualTo(Document.parse("{ \"$trim\" : {\"input\" : \"$field1\", \"chars\" : \"$field2\" }}"));
+ .isEqualTo("{ \"$trim\" : {\"input\" : \"$field1\", \"chars\" : \"$field2\" }}");
}
@Test // DATAMONGO-2077
void shouldRenderLtrimWithoutChars() {
- assertThat(transform("ltrim(field)")).isEqualTo(Document.parse("{ \"$ltrim\" : {\"input\" : \"$field\"}}"));
+ assertThat(transform("ltrim(field)")).isEqualTo("{ \"$ltrim\" : {\"input\" : \"$field\"}}");
}
@Test // DATAMONGO-2077
void shouldRenderLtrimWithChars() {
assertThat(transform("ltrim(field, 'ie')"))
- .isEqualTo(Document.parse("{ \"$ltrim\" : {\"input\" : \"$field\", \"chars\" : \"ie\" }}"));
+ .isEqualTo("{ \"$ltrim\" : {\"input\" : \"$field\", \"chars\" : \"ie\" }}");
}
@Test // DATAMONGO-2077
void shouldRenderLtrimWithCharsFromFieldReference() {
assertThat(transform("ltrim(field1, field2)"))
- .isEqualTo(Document.parse("{ \"$ltrim\" : {\"input\" : \"$field1\", \"chars\" : \"$field2\" }}"));
+ .isEqualTo("{ \"$ltrim\" : {\"input\" : \"$field1\", \"chars\" : \"$field2\" }}");
}
@Test // DATAMONGO-2077
void shouldRenderRtrimWithoutChars() {
- assertThat(transform("rtrim(field)")).isEqualTo(Document.parse("{ \"$rtrim\" : {\"input\" : \"$field\"}}"));
+ assertThat(transform("rtrim(field)")).isEqualTo("{ \"$rtrim\" : {\"input\" : \"$field\"}}");
}
@Test // DATAMONGO-2077
void shouldRenderRtrimWithChars() {
assertThat(transform("rtrim(field, 'ie')"))
- .isEqualTo(Document.parse("{ \"$rtrim\" : {\"input\" : \"$field\", \"chars\" : \"ie\" }}"));
+ .isEqualTo("{ \"$rtrim\" : {\"input\" : \"$field\", \"chars\" : \"ie\" }}");
}
@Test // DATAMONGO-2077
void shouldRenderRtrimWithCharsFromFieldReference() {
assertThat(transform("rtrim(field1, field2)"))
- .isEqualTo(Document.parse("{ \"$rtrim\" : {\"input\" : \"$field1\", \"chars\" : \"$field2\" }}"));
+ .isEqualTo("{ \"$rtrim\" : {\"input\" : \"$field1\", \"chars\" : \"$field2\" }}");
}
@Test // DATAMONGO-2077
void shouldRenderConvertWithoutOptionalParameters() {
assertThat(transform("convert(field, 'string')"))
- .isEqualTo(Document.parse("{ \"$convert\" : {\"input\" : \"$field\", \"to\" : \"string\" }}"));
+ .isEqualTo("{ \"$convert\" : {\"input\" : \"$field\", \"to\" : \"string\" }}");
}
@Test // DATAMONGO-2077
void shouldRenderConvertWithOnError() {
- assertThat(transform("convert(field, 'int', 'Not an integer.')")).isEqualTo(Document
- .parse("{ \"$convert\" : {\"input\" : \"$field\", \"to\" : \"int\", \"onError\" : \"Not an integer.\" }}"));
+ assertThat(transform("convert(field, 'int', 'Not an integer.')"))
+ .isEqualTo("{ \"$convert\" : {\"input\" : \"$field\", \"to\" : \"int\", \"onError\" : \"Not an integer.\" }}");
}
@Test // DATAMONGO-2077
void shouldRenderConvertWithOnErrorOnNull() {
- assertThat(transform("convert(field, 'int', 'Not an integer.', -1)")).isEqualTo(Document.parse(
- "{ \"$convert\" : {\"input\" : \"$field\", \"to\" : \"int\", \"onError\" : \"Not an integer.\", \"onNull\" : -1 }}"));
+ assertThat(transform("convert(field, 'int', 'Not an integer.', -1)")).isEqualTo(
+ "{ \"$convert\" : {\"input\" : \"$field\", \"to\" : \"int\", \"onError\" : \"Not an integer.\", \"onNull\" : -1 }}");
}
@Test // DATAMONGO-2077
void shouldRenderToBool() {
- assertThat(transform("toBool(field)")).isEqualTo(Document.parse("{ \"$toBool\" : \"$field\"}"));
+ assertThat(transform("toBool(field)")).isEqualTo("{ \"$toBool\" : \"$field\"}");
}
@Test // DATAMONGO-2077
void shouldRenderToDate() {
- assertThat(transform("toDate(field)")).isEqualTo(Document.parse("{ \"$toDate\" : \"$field\"}"));
+ assertThat(transform("toDate(field)")).isEqualTo("{ \"$toDate\" : \"$field\"}");
}
@Test // DATAMONGO-2077
void shouldRenderToDecimal() {
- assertThat(transform("toDecimal(field)")).isEqualTo(Document.parse("{ \"$toDecimal\" : \"$field\"}"));
+ assertThat(transform("toDecimal(field)")).isEqualTo("{ \"$toDecimal\" : \"$field\"}");
}
@Test // DATAMONGO-2077
void shouldRenderToDouble() {
- assertThat(transform("toDouble(field)")).isEqualTo(Document.parse("{ \"$toDouble\" : \"$field\"}"));
+ assertThat(transform("toDouble(field)")).isEqualTo("{ \"$toDouble\" : \"$field\"}");
}
@Test // DATAMONGO-2077
void shouldRenderToInt() {
- assertThat(transform("toInt(field)")).isEqualTo(Document.parse("{ \"$toInt\" : \"$field\"}"));
+ assertThat(transform("toInt(field)")).isEqualTo("{ \"$toInt\" : \"$field\"}");
}
@Test // DATAMONGO-2077
void shouldRenderToLong() {
- assertThat(transform("toLong(field)")).isEqualTo(Document.parse("{ \"$toLong\" : \"$field\"}"));
+ assertThat(transform("toLong(field)")).isEqualTo("{ \"$toLong\" : \"$field\"}");
}
@Test // DATAMONGO-2077
void shouldRenderToObjectId() {
- assertThat(transform("toObjectId(field)")).isEqualTo(Document.parse("{ \"$toObjectId\" : \"$field\"}"));
+ assertThat(transform("toObjectId(field)")).isEqualTo("{ \"$toObjectId\" : \"$field\"}");
}
@Test // DATAMONGO-2077
void shouldRenderToString() {
- assertThat(transform("toString(field)")).isEqualTo(Document.parse("{ \"$toString\" : \"$field\"}"));
+ assertThat(transform("toString(field)")).isEqualTo("{ \"$toString\" : \"$field\"}");
}
@Test // DATAMONGO-2077
void shouldRenderDateFromStringWithoutOptionalParameters() {
assertThat(transform("dateFromString(field)"))
- .isEqualTo(Document.parse("{ \"$dateFromString\" : {\"dateString\" : \"$field\" }}"));
+ .isEqualTo("{ \"$dateFromString\" : {\"dateString\" : \"$field\" }}");
}
@Test // DATAMONGO-2077
void shouldRenderDateFromStringWithFormat() {
assertThat(transform("dateFromString(field, 'DD-MM-YYYY')")).isEqualTo(
- Document.parse("{ \"$dateFromString\" : {\"dateString\" : \"$field\", \"format\" : \"DD-MM-YYYY\" }}"));
+ "{ \"$dateFromString\" : {\"dateString\" : \"$field\", \"format\" : \"DD-MM-YYYY\" }}");
}
@Test // DATAMONGO-2077
void shouldRenderDateFromStringWithFormatAndTimezone() {
- assertThat(transform("dateFromString(field, 'DD-MM-YYYY', 'UTC')")).isEqualTo(Document.parse(
- "{ \"$dateFromString\" : {\"dateString\" : \"$field\", \"format\" : \"DD-MM-YYYY\", \"timezone\" : \"UTC\" }}"));
+ assertThat(transform("dateFromString(field, 'DD-MM-YYYY', 'UTC')")).isEqualTo(
+ "{ \"$dateFromString\" : {\"dateString\" : \"$field\", \"format\" : \"DD-MM-YYYY\", \"timezone\" : \"UTC\" }}");
}
@Test // DATAMONGO-2077
void shouldRenderDateFromStringWithFormatTimezoneAndOnError() {
- assertThat(transform("dateFromString(field, 'DD-MM-YYYY', 'UTC', -1)")).isEqualTo(Document.parse(
- "{ \"$dateFromString\" : {\"dateString\" : \"$field\", \"format\" : \"DD-MM-YYYY\", \"timezone\" : \"UTC\", \"onError\" : -1 }}"));
+ assertThat(transform("dateFromString(field, 'DD-MM-YYYY', 'UTC', -1)")).isEqualTo(
+ "{ \"$dateFromString\" : {\"dateString\" : \"$field\", \"format\" : \"DD-MM-YYYY\", \"timezone\" : \"UTC\", \"onError\" : -1 }}");
}
@Test // DATAMONGO-2077
void shouldRenderDateFromStringWithFormatTimezoneOnErrorAndOnNull() {
- assertThat(transform("dateFromString(field, 'DD-MM-YYYY', 'UTC', -1, -2)")).isEqualTo(Document.parse(
- "{ \"$dateFromString\" : {\"dateString\" : \"$field\", \"format\" : \"DD-MM-YYYY\", \"timezone\" : \"UTC\", \"onError\" : -1, \"onNull\" : -2}}"));
+ assertThat(transform("dateFromString(field, 'DD-MM-YYYY', 'UTC', -1, -2)")).isEqualTo(
+ "{ \"$dateFromString\" : {\"dateString\" : \"$field\", \"format\" : \"DD-MM-YYYY\", \"timezone\" : \"UTC\", \"onError\" : -1, \"onNull\" : -2}}");
}
@Test // DATAMONGO-2077, DATAMONGO-2671
void shouldRenderDateFromParts() {
- assertThat(transform("dateFromParts(y, m, d, h, mm, s, ms, 'UTC')")).isEqualTo(Document.parse(
- "{ \"$dateFromParts\" : {\"year\" : \"$y\", \"month\" : \"$m\", \"day\" : \"$d\", \"hour\" : \"$h\", \"minute\" : \"$mm\", \"second\" : \"$s\", \"millisecond\" : \"$ms\", \"timezone\" : \"UTC\"}}"));
+ assertThat(transform("dateFromParts(y, m, d, h, mm, s, ms, 'UTC')")).isEqualTo(
+ "{ \"$dateFromParts\" : {\"year\" : \"$y\", \"month\" : \"$m\", \"day\" : \"$d\", \"hour\" : \"$h\", \"minute\" : \"$mm\", \"second\" : \"$s\", \"millisecond\" : \"$ms\", \"timezone\" : \"UTC\"}}");
}
@Test // DATAMONGO-2077, DATAMONGO-2671
void shouldRenderIsoDateFromParts() {
- assertThat(transform("isoDateFromParts(y, m, d, h, mm, s, ms, 'UTC')")).isEqualTo(Document.parse(
- "{ \"$dateFromParts\" : {\"isoWeekYear\" : \"$y\", \"isoWeek\" : \"$m\", \"isoDayOfWeek\" : \"$d\", \"hour\" : \"$h\", \"minute\" : \"$mm\", \"second\" : \"$s\", \"millisecond\" : \"$ms\", \"timezone\" : \"UTC\"}}"));
+ assertThat(transform("isoDateFromParts(y, m, d, h, mm, s, ms, 'UTC')")).isEqualTo(
+ "{ \"$dateFromParts\" : {\"isoWeekYear\" : \"$y\", \"isoWeek\" : \"$m\", \"isoDayOfWeek\" : \"$d\", \"hour\" : \"$h\", \"minute\" : \"$mm\", \"second\" : \"$s\", \"millisecond\" : \"$ms\", \"timezone\" : \"UTC\"}}");
}
@Test // DATAMONGO-2077
void shouldRenderDateToParts() {
assertThat(transform("dateToParts(field, 'UTC', false)")).isEqualTo(
- Document.parse("{ \"$dateToParts\" : {\"date\" : \"$field\", \"timezone\" : \"UTC\", \"iso8601\" : false}}"));
+ "{ \"$dateToParts\" : {\"date\" : \"$field\", \"timezone\" : \"UTC\", \"iso8601\" : false}}");
}
@Test // DATAMONGO-2077
void shouldRenderIndexOfArray() {
assertThat(transform("indexOfArray(field, 2)"))
- .isEqualTo(Document.parse("{ \"$indexOfArray\" : [\"$field\", 2 ]}"));
+ .isEqualTo("{ \"$indexOfArray\" : [\"$field\", 2 ]}");
}
@Test // DATAMONGO-2077
void shouldRenderRange() {
- assertThat(transform("range(0, 10, 2)")).isEqualTo(Document.parse("{ \"$range\" : [0, 10, 2 ]}"));
+ assertThat(transform("range(0, 10, 2)")).isEqualTo("{ \"$range\" : [0, 10, 2 ]}");
}
@Test // DATAMONGO-2370
void shouldRenderRound() {
- assertThat(transform("round(field)")).isEqualTo(Document.parse("{ \"$round\" : [\"$field\"]}"));
+ assertThat(transform("round(field)")).isEqualTo("{ \"$round\" : [\"$field\"]}");
}
@Test // DATAMONGO-2370
void shouldRenderRoundWithPlace() {
- assertThat(transform("round(field, 2)")).isEqualTo(Document.parse("{ \"$round\" : [\"$field\", 2]}"));
+ assertThat(transform("round(field, 2)")).isEqualTo("{ \"$round\" : [\"$field\", 2]}");
}
@Test // GH-3714
void shouldRenderDegreesToRadians() {
- assertThat(transform("degreesToRadians(angle_a)")).isEqualTo(Document.parse("{ \"$degreesToRadians\" : \"$angle_a\"}"));
+ assertThat(transform("degreesToRadians(angle_a)")).isEqualTo("{ \"$degreesToRadians\" : \"$angle_a\"}");
}
@Test // GH-3712
void shouldRenderCovariancePop() {
assertThat(transform("covariancePop(field1, field2)"))
- .isEqualTo(Document.parse("{ \"$covariancePop\" : [\"$field1\", \"$field2\"]}"));
+ .isEqualTo("{ \"$covariancePop\" : [\"$field1\", \"$field2\"]}");
}
@Test // GH-3712
void shouldRenderCovarianceSamp() {
assertThat(transform("covarianceSamp(field1, field2)"))
- .isEqualTo(Document.parse("{ \"$covarianceSamp\" : [\"$field1\", \"$field2\"]}"));
+ .isEqualTo("{ \"$covarianceSamp\" : [\"$field1\", \"$field2\"]}");
}
@Test // GH-3715
void shouldRenderRank() {
- assertThat(transform("rank()")).isEqualTo(Document.parse("{ $rank : {} }"));
+ assertThat(transform("rank()")).isEqualTo("{ $rank : {} }");
}
@Test // GH-3715
void shouldRenderDenseRank() {
- assertThat(transform("denseRank()")).isEqualTo(Document.parse("{ $denseRank : {} }"));
+ assertThat(transform("denseRank()")).isEqualTo("{ $denseRank : {} }");
}
@Test // GH-3717
void shouldRenderDocumentNumber() {
- assertThat(transform("documentNumber()")).isEqualTo(Document.parse("{ $documentNumber : {} }"));
+ assertThat(transform("documentNumber()")).isEqualTo("{ $documentNumber : {} }");
}
@Test // GH-3727
void rendersShift() {
assertThat(transform("shift(quantity, 1)"))
- .isEqualTo(Document.parse("{ $shift: { output: \"$quantity\", by: 1 } }"));
+ .isEqualTo("{ $shift: { output: \"$quantity\", by: 1 } }");
}
@Test // GH-3727
void rendersShiftWithDefault() {
assertThat(transform("shift(quantity, 1, 'Not available')"))
- .isEqualTo(Document.parse("{ $shift: { output: \"$quantity\", by: 1, default: \"Not available\" } }"));
+ .isEqualTo("{ $shift: { output: \"$quantity\", by: 1, default: \"Not available\" } }");
}
@Test // GH-3716
void shouldRenderDerivative() {
assertThat(transform("derivative(miles, 'hour')"))
- .isEqualTo(Document.parse("{ \"$derivative\" : { input : '$miles', unit : 'hour'} }"));
+ .isEqualTo("{ \"$derivative\" : { input : '$miles', unit : 'hour'} }");
}
@Test // GH-3721
void shouldRenderIntegral() {
- assertThat(transform("integral(field)")).isEqualTo(Document.parse("{ \"$integral\" : { \"input\" : \"$field\" }}"));
+ assertThat(transform("integral(field)")).isEqualTo("{ \"$integral\" : { \"input\" : \"$field\" }}");
}
@Test // GH-3721
void shouldRenderIntegralWithUnit() {
assertThat(transform("integral(field, 'hour')"))
- .isEqualTo(Document.parse("{ \"$integral\" : { \"input\" : \"$field\", \"unit\" : \"hour\" }}"));
+ .isEqualTo("{ \"$integral\" : { \"input\" : \"$field\", \"unit\" : \"hour\" }}");
}
@Test // GH-3728
void shouldRenderSin() {
- assertThat(transform("sin(angle)")).isEqualTo(Document.parse("{ \"$sin\" : \"$angle\"}"));
+ assertThat(transform("sin(angle)")).isEqualTo("{ \"$sin\" : \"$angle\"}");
}
@Test // GH-3728
void shouldRenderSinh() {
- assertThat(transform("sinh(angle)")).isEqualTo(Document.parse("{ \"$sinh\" : \"$angle\"}"));
+ assertThat(transform("sinh(angle)")).isEqualTo("{ \"$sinh\" : \"$angle\"}");
}
@Test // GH-3710
void shouldRenderCos() {
- assertThat(transform("cos(angle)")).isEqualTo(Document.parse("{ \"$cos\" : \"$angle\"}"));
+ assertThat(transform("cos(angle)")).isEqualTo("{ \"$cos\" : \"$angle\"}");
}
@Test // GH-3710
void shouldRenderCosh() {
- assertThat(transform("cosh(angle)")).isEqualTo(Document.parse("{ \"$cosh\" : \"$angle\"}"));
+ assertThat(transform("cosh(angle)")).isEqualTo("{ \"$cosh\" : \"$angle\"}");
}
@Test // GH-3730
void shouldRenderTan() {
- assertThat(transform("tan(angle)")).isEqualTo(Document.parse("{ \"$tan\" : \"$angle\"}"));
+ assertThat(transform("tan(angle)")).isEqualTo("{ \"$tan\" : \"$angle\"}");
}
@Test // GH-3730
void shouldRenderTanh() {
- assertThat(transform("tanh(angle)")).isEqualTo(Document.parse("{ \"$tanh\" : \"$angle\"}"));
+ assertThat(transform("tanh(angle)")).isEqualTo("{ \"$tanh\" : \"$angle\"}");
}
- private Object transform(String expression, Object... params) {
+ private Document transform(String expression, Object... params) {
+ return (Document) transformer.transform(expression, Aggregation.DEFAULT_CONTEXT, params);
+ }
+
+ private Object transformValue(String expression, Object... params) {
Object result = transformer.transform(expression, Aggregation.DEFAULT_CONTEXT, params);
return result == null ? null : (!(result instanceof org.bson.Document) ? result.toString() : result);
}
diff --git a/src/main/asciidoc/reference/aggregation-framework.adoc b/src/main/asciidoc/reference/aggregation-framework.adoc
index 9b00811a7..6373eb663 100644
--- a/src/main/asciidoc/reference/aggregation-framework.adoc
+++ b/src/main/asciidoc/reference/aggregation-framework.adoc
@@ -85,7 +85,7 @@ At the time of this writing, we provide support for the following Aggregation Op
| `addToSet`, `covariancePop`, `covarianceSamp`, `expMovingAvg`, `first`, `last`, `max`, `min`, `avg`, `push`, `sum`, `count` (+++*+++), `stdDevPop`, `stdDevSamp`
| Arithmetic Aggregation Operators
-| `abs`, `add` (+++*+++ via `plus`), `ceil`, `derivative`, `divide`, `exp`, `floor`, `integral`, `ln`, `log`, `log10`, `mod`, `multiply`, `pow`, `round`, `sqrt`, `subtract` (+++*+++ via `minus`), `trunc`
+| `abs`, `add` (+++*+++ via `plus`), `ceil`, `cos`, `cosh`, `derivative`, `divide`, `exp`, `floor`, `integral`, `ln`, `log`, `log10`, `mod`, `multiply`, `pow`, `round`, `sqrt`, `subtract` (+++*+++ via `minus`), `sin`, `sinh`, `tan`, `tanh`, `trunc`
| String Aggregation Operators
| `concat`, `substr`, `toLower`, `toUpper`, `stcasecmp`, `indexOfBytes`, `indexOfCP`, `split`, `strLenBytes`, `strLenCP`, `substrCP`, `trim`, `ltrim`, `rtim`
@@ -112,7 +112,7 @@ At the time of this writing, we provide support for the following Aggregation Op
| `type`
| Convert Aggregation Operators
-| `convert`, `toBool`, `toDate`, `toDecimal`, `toDouble`, `toInt`, `toLong`, `toObjectId`, `toString`
+| `convert`, `degreesToRadians`, `toBool`, `toDate`, `toDecimal`, `toDouble`, `toInt`, `toLong`, `toObjectId`, `toString`
| Object Aggregation Operators
| `objectToArray`, `mergeObjects`