mungedb-aggregate/test/lib/pipeline/expressions/NaryExpression.js

"use strict";
var assert = require("assert"),
	VariablesParseState = require("../../../../lib/pipeline/expressions/VariablesParseState"),
	VariablesIdGenerator = require("../../../../lib/pipeline/expressions/VariablesIdGenerator"),
	NaryExpression = require("../../../../lib/pipeline/expressions/NaryExpression"),
	ConstantExpression = require("../../../../lib/pipeline/expressions/ConstantExpression"),
	FieldPathExpression = require("../../../../lib/pipeline/expressions/FieldPathExpression"),
	Expression = require("../../../../lib/pipeline/expressions/Expression");


// A dummy child of NaryExpression used for testing
var TestableExpression = (function(){
	// CONSTRUCTOR
	var klass = function TestableExpression(operands, haveFactory){
		base.call(this);
		if (operands) {
			var self = this;
			operands.forEach(function(operand) {
				self.addOperand(operand);
			});
		}
		this.haveFactory = !!haveFactory;
	}, base = NaryExpression, proto = klass.prototype = Object.create(base.prototype, {constructor:{value:klass}});

	// PROTOTYPE MEMBERS
	proto.evaluateInternal = function evaluateInternal(vps) {
		// Just put all the values in a list.  This is not associative/commutative so
		// the results will change if a factory is provided and operations are reordered.
		return this.operands.map(function(operand) {
			return operand.evaluateInternal(vps);
		});
	};

	proto.isAssociativeAndCommutative = function isAssociativeAndCommutative(){
		return this.isAssociativeAndCommutative;
	};

	proto.getOpName = function getOpName() {
		return "$testable";
	};

	klass.createFromOperands = function(operands) {
		var vps = new VariablesParseState(new VariablesIdGenerator()),
			testable = new TestableExpression();
		operands.forEach(function(x) {
			testable.addOperand(Expression.parseOperand(x, vps));
		});
		return testable;
	};

	return klass;
})();


module.exports = {

	"NaryExpression": {

		"constructor()": {

		},

		"#optimize()": {

			"should suboptimize": function() {
				var testable = TestableExpression.createFromOperands([{"$and": []}, "$abc"], true);
				testable = testable.optimize();
				assert.deepEqual(testable.serialize(), {$testable: [true,"$abc"]});
			},
			"should fold constants": function() {
				var testable = TestableExpression.createFromOperands([1,2], true);
				testable = testable.optimize();
				assert.deepEqual(testable.serialize(), {$const: [1,2]});
			},

			"should place constants at the end of operands array": function() {
				var testable = TestableExpression.createFromOperands([55,65, "$path"], true);
				testable = testable.optimize();
				assert.deepEqual(testable.serialize(), {$testable:["$path", [55,66]]});
			},

			"should flatten two layers" : function() {
				var testable = TestableExpression.createFromOperands([55, "$path", {$add: [5,6,"$q"]}], true);
				testable.addOperand(TestableExpression.createFromOperands([99,100,"$another_path"], true));
				testable = testable.optimize();
				assert.deepEqual(testable.serialize(), {$testable: ["$path", {$add: [5,6,"$q"]}, "$another_path", [55,66,[99,100]]]});
			},

			"should flatten three layers": function(){
				var bottom = TestableExpression.createFromOperands([5,6,"$c"], true),
					middle = TestableExpression.createFromOperands([3,4,"$b"], true).addOperand(bottom),
					top = TestableExpression.createFromOperands([1,2,"$a"], true);
				var testable = top.optimize();
				assert.deepEqual(testable.serialize(), {$testable: ["$a", "$b", "$c", [1,2,[3,4,[5,6]]]]});
			}

		},

		"#addOperand() should be able to add operands to expressions": function testAddOperand(){
			var foo = new TestableExpression([new ConstantExpression(9)]).serialize();
			var bar = new TestableExpression([new ConstantExpression(9)]).serialize();
			var baz = {"$testable":[{"$const":9}]};

			assert.deepEqual(foo,bar);
			assert.deepEqual(foo, baz);
			assert.deepEqual(baz,foo);
			assert.deepEqual(new TestableExpression([new ConstantExpression(9)]).serialize(), {"$testable":[{"$const":9}]});
			assert.deepEqual(new TestableExpression([new FieldPathExpression("ab.c")]).serialize(), {$testable:["$ab.c"]});
		},


		"#serialize() should convert an object to json": function(){
			var testable = new TestableExpression();
			testable.addOperand(new ConstantExpression(5));
			assert.deepEqual({foo: testable.serialize()}, {foo:{$testable:[{$const: 5}]}});
		},


		//the following test case is eagerly awaiting ObjectExpression
		"#addDependencies()": function testDependencies(){
			var testableExpr = new TestableExpression();
			var deps = {};
			// no arguments
			testableExpr.addDependencies(deps);
			assert.deepEqual(deps, {});

			// add a constant argument
			testableExpr.addOperand(new ConstantExpression(1));

			deps = {};
			testableExpr.addDependencies(deps);
			assert.deepEqual(deps, {});

			// add a field path argument
			testableExpr.addOperand(new FieldPathExpression("ab.c"));
			deps = {};
			testableExpr.addDependencies(deps);
			assert.deepEqual(deps, {"ab.c":1});

			// add an object expression
			testableExpr.addOperand(Expression.parseObject({a:"$x",q:"$r"}, new Expression.ObjectCtx({isDocumentOk:1})));
			deps = {};
			testableExpr.addDependencies(deps);
			assert.deepEqual(deps, {"ab.c":1, "x":1, "r":1});
		}

	}

};

if (!module.parent)(new(require("mocha"))()).ui("exports").reporter("spec").addFile(__filename).run(process.exit);