Merge branch 'feature/mongo_2.6.5_expressions' into feature/mongo_2.6.5_expressions_Date

lib/pipeline/expressions/AnyElementTrueExpression.js

@@ -33,12 +33,14 @@ proto.getOpName = function getOpName(){
  * @method @evaluateInternal
  **/
 proto.evaluateInternal = function evaluateInternal(vars) {
-	if (!vars instanceof Array) throw new Error("$anyElementTrue requires an array");
-
-	var total = 0;
-	for (var i = 0, n = vars.length; i < n; ++i) {
-		var value = vars[i].evaluateInternal([i]);
-		if ( value.coerceToBool() )
+	var arr = this.operands[0].evaluateInternal(vars);
+	if (!(arr instanceof Array)) {
+		throw new Error("uassert 17041: $anyElementTrue's " +
+						"argument must be an array, but is " +
+						typeof arr);
+	}
+	for (var i=0, n=arr.length; i<n; ++i) {
+		if (Value.coerceToBool(arr[i]))
 			return true;
 	}
 	return false;

test/lib/pipeline/expressions/AnyElementTrueExpression.js

@@ -1,10 +1,20 @@
 "use strict";
 var assert = require("assert"),
+	VariablesIdGenerator = require("../../../../lib/pipeline/expressions/VariablesIdGenerator"),
+	VariablesParseState = require("../../../../lib/pipeline/expressions/VariablesParseState"),
 	AnyElementTrueExpression = require("../../../../lib/pipeline/expressions/AnyElementTrueExpression"),
 	Expression = require("../../../../lib/pipeline/expressions/Expression");
 
 var anyElementTrueExpression = new AnyElementTrueExpression();
 
+function errMsg(expr, args, tree, expected, result) {
+	return 	"for expression " + expr +
+			" with argument " + args +
+			" full tree: " + JSON.stringify(tree) +
+			" expected: " + expected +
+			" result: " + result;
+}
+
 module.exports = {
 
 	"AnyElementTrueExpression": {
@@ -27,25 +37,84 @@ module.exports = {
 
 		},
 
-		"#evaluateInternal()": {
+		"integration": {
+
+			"JustFalse": function JustFalse(){
+				var idGenerator = new VariablesIdGenerator(),
+					vps = new VariablesParseState(idGenerator),
+					input = [[false]],
+					expr = Expression.parseExpression("$anyElementTrue", input),
+					result = expr.evaluate({}),
+					expected = false,
+					msg = errMsg("$anyElementTrue", input, expr.serialize(false), expected, result);
+				assert.equal(result, expected, msg);
+			},
+
+			"JustTrue": function JustTrue(){
+				var idGenerator = new VariablesIdGenerator(),
+					vps = new VariablesParseState(idGenerator),
+					input = [[true]],
+					expr = Expression.parseExpression("$anyElementTrue", input),
+					result = expr.evaluate({}),
+					expected = true,
+					msg = errMsg("$anyElementTrue", input, expr.serialize(false), expected, result);
+				assert.equal(result, expected, msg);
+			},
 
-			"should return error if parameter is not an array": function testEmpty(){
-				assert.throws(function(){
-					anyElementTrueExpression.evaluateInternal("TEST");});
+			"OneTrueOneFalse": function OneTrueOneFalse(){
+				var idGenerator = new VariablesIdGenerator(),
+					vps = new VariablesParseState(idGenerator),
+					input = [[true, false]],
+					expr = Expression.parseExpression("$anyElementTrue", input),
+					result = expr.evaluate({}),
+					expected = true,
+					msg = errMsg("$anyElementTrue", input, expr.serialize(false), expected, result);
+				assert.equal(result, expected, msg);
 			},
 
-			"should return true if only true was given a; {true}": function testEmpty(){
-				assert.equal(anyElementTrueExpression.evaluateInternal({$anyElementTrue:[1,2,3,4]}), false);
+			"Empty": function Empty(){
+				var idGenerator = new VariablesIdGenerator(),
+					vps = new VariablesParseState(idGenerator),
+					input = [[]],
+					expr = Expression.parseExpression("$anyElementTrue", input),
+					result = expr.evaluate({}),
+					expected = false,
+					msg = errMsg("$anyElementTrue", input, expr.serialize(false), expected, result);
+				assert.equal(result, expected, msg);
 			},
 
-			"should return false if no element is true": function testEmpty(){
-				assert.equal(anyElementTrueExpression.evaluateInternal({$anyElementTrue:[1,2,3,4]}), false);
+			"TrueViaInt": function TrueViaInt(){
+				var idGenerator = new VariablesIdGenerator(),
+					vps = new VariablesParseState(idGenerator),
+					input = [[1]],
+					expr = Expression.parseExpression("$anyElementTrue", input),
+					result = expr.evaluate({}),
+					expected = true,
+					msg = errMsg("$anyElementTrue", input, expr.serialize(false), expected, result);
+				assert.equal(result, expected, msg);
 			},
 
-			"should return true if any element is true": function testEmpty(){
-				assert.equal(anyElementTrueExpression.evaluateInternal({$anyElementTrue:[1,true,2,3,4]}), true);
+			"FalseViaInt": function FalseViaInt(){
+				var idGenerator = new VariablesIdGenerator(),
+					vps = new VariablesParseState(idGenerator),
+					input = [[0]],
+					expr = Expression.parseExpression("$anyElementTrue", input),
+					result = expr.evaluate({}),
+					expected = false,
+					msg = errMsg("$anyElementTrue", input, expr.serialize(false), expected, result);
+				assert.equal(result, expected, msg);
 			},
 
+			"Null": function FalseViaInt(){
+				var idGenerator = new VariablesIdGenerator(),
+					vps = new VariablesParseState(idGenerator),
+					input = [null],
+					expr = Expression.parseExpression("$anyElementTrue", input);
+				assert.throws(function() {
+					var result = expr.evaluate({});
+				});
+			}
+
 		}
 
 	}

test/lib/pipeline/expressions/ConstantExpression_test.js

@@ -2,31 +2,31 @@
 var assert = require("assert"),
 	ConstantExpression = require("../../../../lib/pipeline/expressions/ConstantExpression"),
 	VariablesIdGenerator = require("../../../../lib/pipeline/expressions/VariablesIdGenerator"),
-	VariablesParseState = require("../../../../lib/pipeline/expressions/VariablesParseState");
+	VariablesParseState = require("../../../../lib/pipeline/expressions/VariablesParseState"),
+	DepsTracker = require("../../../../lib/pipeline/DepsTracker");
 
 // Mocha one-liner to make these tests self-hosted
-if(!module.parent)return(require.cache[__filename]=null,(new(require("mocha"))({ui:"exports",reporter:"spec",grep:process.env.TEST_GREP})).addFile(__filename).run(process.exit));
+if (!module.parent)return(require.cache[__filename] = null, (new (require("mocha"))({ui: "exports", reporter: "spec", grep: process.env.TEST_GREP})).addFile(__filename).run(process.exit));
 
 exports.ConstantExpression = {
 
 	".constructor()": {
 
-		"should accept one argument": function() {
+		"should accept one argument": function () {
 			new ConstantExpression(5);
 		},
 
-		"should not accept 0 arguments": function() {
-			assert.throws(function() {
-				 new ConstantExpression();
+		"should not accept 0 arguments": function () {
+			assert.throws(function () {
+				new ConstantExpression();
 			});
 		},
 
-		"should not accept 2 arguments": function() {
-			assert.throws(function() {
+		"should not accept 2 arguments": function () {
+			assert.throws(function () {
 				new ConstantExpression(1, 2);
 			});
-		},
-
+		}
 	},
 
 	".parse()": {
@@ -36,18 +36,15 @@ exports.ConstantExpression = {
 				vps = new VariablesParseState(idGenerator),
 				expression = ConstantExpression.parse("foo", vps);
 			assert.deepEqual("foo", expression.evaluate({}));
-		},
-
+		}
 	},
 
 	".create()": {
 
 		"should create an expression": function testCreate() {
 			assert(ConstantExpression.create() instanceof ConstantExpression);
-		},
-
+		}
 		//SKIPPED: testCreateFronBsonElement
-
 	},
 
 	"#optimize()": {
@@ -55,21 +52,19 @@ exports.ConstantExpression = {
 		"should not optimize anything": function testOptimize() {
 			var expr = new ConstantExpression(5);
 			assert.strictEqual(expr, expr.optimize());
-		},
-
+		}
 	},
 
 	"#addDependencies()": {
 
 		"should return nothing": function testDependencies() {
 			var expr = ConstantExpression.create(5),
-				deps = {}; //TODO: new DepsTracker
+				deps = new DepsTracker();
 			expr.addDependencies(deps);
-			assert.strictEqual(deps.fields.length, 0);
+			assert.deepEqual(deps.fields, {});
 			assert.strictEqual(deps.needWholeDocument, false);
 			assert.strictEqual(deps.needTextScore, false);
-		},
-
+		}
 	},
 
 	//TODO: AddToBsonObj
@@ -78,30 +73,28 @@ exports.ConstantExpression = {
 
 	"#evaluate()": {
 
-		"should do what comes natural with an int": function() {
+		"should do what comes natural with an int": function () {
 			var c = 567;
 			var expr = new ConstantExpression(c);
 			assert.deepEqual(expr.evaluate(), c);
 		},
 
-		"should do what comes natural with a float": function() {
+		"should do what comes natural with a float": function () {
 			var c = 567.123;
 			var expr = new ConstantExpression(c);
 			assert.deepEqual(expr.evaluate(), c);
 		},
 
-		"should do what comes natural with a String": function() {
+		"should do what comes natural with a String": function () {
 			var c = "Quoth the raven";
 			var expr = new ConstantExpression(c);
 			assert.deepEqual(expr.evaluate(), c);
 		},
 
-		"should do what comes natural with a date": function() {
+		"should do what comes natural with a date": function () {
 			var c = new Date();
 			var expr = new ConstantExpression(c);
 			assert.deepEqual(expr.evaluate(), c);
-		},
-
-	},
-
+		}
+	}
 };