EAGLESIX-2651: Date: fix minor bugs during review

lib/pipeline/expressions/SubtractExpression.js

@@ -4,65 +4,50 @@
  * A $subtract pipeline expression.
  * @see evaluateInternal
  * @class SubtractExpression
+ * @extends mungedb-aggregate.pipeline.expressions.FixedArityExpressionT
  * @namespace mungedb-aggregate.pipeline.expressions
  * @module mungedb-aggregate
  * @constructor
- **/
-var SubtractExpression = module.exports = function SubtractExpression(){
+ */
+var SubtractExpression = module.exports = function SubtractExpression() {
 	base.call(this);
-}, klass = SubtractExpression,
-	FixedArityExpression = require("./FixedArityExpressionT")(klass, 2),
-	base = FixedArityExpression,
-	proto = klass.prototype = Object.create(base.prototype, {
-		constructor: {
-			value: klass
-		}
-	});
+}, klass = SubtractExpression, base = require("./FixedArityExpressionT")(SubtractExpression, 2), proto = klass.prototype = Object.create(base.prototype, {constructor:{value:klass}});
 
-// DEPENDENCIES
 var Value = require("../Value"),
 	Expression = require("./Expression");
 
-// PROTOTYPE MEMBERS
-proto.getOpName = function getOpName(){
-	return "$subtract";
-};
-
-/**
-* Takes an array that contains a pair of numbers and subtracts the second from the first, returning their difference.
-**/
 proto.evaluateInternal = function evaluateInternal(vars) {
-	var left = this.operands[0].evaluateInternal(vars),
-		right = this.operands[1].evaluateInternal(vars);
-	if (typeof left === 'number' && typeof right === 'number') {
-		return left - right;
-	}
-	//NOTE: DEVIATION FROM MONGO: inlined left.nullish() || right.nullish()
-	else if (left === null || left === undefined || right === null || right === undefined) {
+	var lhs = this.operands[0].evaluateInternal(vars),
+		rhs = this.operands[1].evaluateInternal(vars);
+
+	if (typeof lhs === "number" && typeof rhs === "number") {
+		return lhs - rhs;
+	} else if (lhs === null || lhs === undefined || rhs === null || rhs === undefined) {
 		return null;
-	}
-	else if (left instanceof Date) {
-		if (right instanceof Date) {
-			return left - right;
-		}
-		else if (typeof right === 'number') {
-			var millisSinceEpoch = left - right;
-			return new Date(millisSinceEpoch);
+	} else if (lhs instanceof Date) {
+		if (rhs instanceof Date) {
+			var timeDelta = lhs - rhs;
+			return timeDelta;
+		} else if (typeof rhs === "number") {
+			var millisSinceEpoch = lhs - Value.coerceToLong(rhs);
+			return millisSinceEpoch;
 		} else {
-			throw new Error("uassert 16613: " +
-				"can't $subtract a " +
-				typeof right +
-				" from a Date");
+			throw new Error("can't $subtract a " +
+				Value.getType(rhs) +
+				" from a Date" +
+				"; uassert code 16613");
 		}
-	}
-	else {
-		throw new Error("uassert 16556: " +
-			"can't $subtract a " +
-			typeof right +
+	} else {
+		throw new Error("can't $subtract a " +
+			Value.getType(rhs) +
 			" from a " +
-			typeof left);
+			Value.getType(lhs) +
+			"; uassert code 16556");
 	}
 };
 
-/** Register Expression */
 Expression.registerExpression("$subtract", base.parse);
+
+proto.getOpName = function getOpName() {
+	return "$subtract";
+};

test/lib/pipeline/expressions/SubtractExpression.js

@@ -5,126 +5,125 @@ var assert = require("assert"),
 		VariablesIdGenerator = require("../../../../lib/pipeline/expressions/VariablesIdGenerator"),
 		VariablesParseState = require("../../../../lib/pipeline/expressions/VariablesParseState");
 
-
-module.exports = {
-
-		"SubtractExpression": {
-
-				"constructor()": {
-
-						"should not throw Error when constructing without args": function testConstructor() {
-								assert.doesNotThrow(function() {
-										new SubtractExpression();
-								});
-						}
-
-				},
-
-				"#getOpName()": {
-
-						"should return the correct op name; $subtract": function testOpName() {
-								assert.equal(new SubtractExpression().getOpName(), "$subtract");
-						}
-
-				},
-
-				"#evaluateInternal()": {
-
-						"should return the result of subtraction between two numbers": function testStuff() {
-							var idGenerator = new VariablesIdGenerator(),
-								vps = new VariablesParseState(idGenerator),
-								expr = Expression.parseOperand({$subtract:["$a", "$b"]}, vps),
-								result = expr.evaluate({a:2, b:1}),
-								expected = 1;
-							assert.equal(result, expected);
-						},
-
-						"should return null if left is null": function testStuff() {
-							var idGenerator = new VariablesIdGenerator(),
-								vps = new VariablesParseState(idGenerator),
-								expr = Expression.parseOperand({$subtract:["$a", "$b"]}, vps),
-								result = expr.evaluate({a:null, b:1}),
-								expected = null;
-							assert.equal(result, expected);
-						},
-
-						"should return null if left is undefined": function testStuff() {
-							var idGenerator = new VariablesIdGenerator(),
-								vps = new VariablesParseState(idGenerator),
-								expr = Expression.parseOperand({$subtract:["$a", "$b"]}, vps),
-								result = expr.evaluate({a:undefined, b:1}),
-								expected = null;
-							assert.equal(result, expected);
-						},
-
-						"should return null if right is null": function testStuff() {
-							var idGenerator = new VariablesIdGenerator(),
-								vps = new VariablesParseState(idGenerator),
-								expr = Expression.parseOperand({$subtract:["$a", "$b"]}, vps),
-								result = expr.evaluate({a:2, b:null}),
-								expected = null;
-							assert.equal(result, expected);
-						},
-
-						"should return null if right is undefined": function testStuff() {
-							var idGenerator = new VariablesIdGenerator(),
-								vps = new VariablesParseState(idGenerator),
-								expr = Expression.parseOperand({$subtract:["$a", "$b"]}, vps),
-								result = expr.evaluate({a:2, b:undefined}),
-								expected = null;
-							assert.equal(result, expected);
-						},
-
-						"should subtract 2 dates": function testStuff() {
-							var idGenerator = new VariablesIdGenerator(),
-								vps = new VariablesParseState(idGenerator),
-								expr = Expression.parseOperand({$subtract:["$a", "$b"]}, vps),
-								date2 = new Date("Jan 3 1990"),
-								date1 = new Date("Jan 1 1990"),
-								result = expr.evaluate({a:date2, b:date1}),
-								expected = date2 - date1;
-							assert.equal(result, expected);
-						},
-
-						"should subtract a number of millis from a date": function testStuff() {
-							var idGenerator = new VariablesIdGenerator(),
-								vps = new VariablesParseState(idGenerator),
-								expr = Expression.parseOperand({$subtract:["$a", "$b"]}, vps),
-								date2 = new Date("Jan 3 1990"),
-								millis = 24 * 60 * 60 * 1000,
-								result = expr.evaluate({a:date2, b:millis}),
-								expected = new Date(date2 - millis);
-							assert.strictEqual(
-								JSON.stringify(result),
-								JSON.stringify(expected)
-							);
-						},
-
-						"should throw if left is not a date or number": function testStuff() {
-							var idGenerator = new VariablesIdGenerator(),
-								vps = new VariablesParseState(idGenerator),
-								expr = Expression.parseOperand({$subtract:["$a", "$b"]}, vps),
-								date2 = {},
-								date1 = new Date();
-							assert.throws(function() {
-								expr.evaluate({a:date2, b:date1});
-							});
-						},
-
-						"should throw if right is not a date or number": function testStuff() {
-							var idGenerator = new VariablesIdGenerator(),
-								vps = new VariablesParseState(idGenerator),
-								expr = Expression.parseOperand({$subtract:["$a", "$b"]}, vps),
-								date2 = new Date(),
-								date1 = {};
-							assert.throws(function() {
-								expr.evaluate({a:date2, b:date1});
-							});
-						}
-				}
-
-		}
+// 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));
+
+exports.SubtractExpression = {
+
+	"constructor()": {
+
+		"should not throw Error when constructing without args": function() {
+			assert.doesNotThrow(function() {
+				new SubtractExpression();
+			});
+		},
+
+	},
+
+	"#getOpName()": {
+
+		"should return the correct op name; $subtract": function() {
+			assert.equal(new SubtractExpression().getOpName(), "$subtract");
+		},
+
+	},
+
+	"#evaluateInternal()": {
+
+		"should return the result of subtraction between two numbers": function() {
+			var idGenerator = new VariablesIdGenerator(),
+				vps = new VariablesParseState(idGenerator),
+				expr = Expression.parseOperand({$subtract:["$a", "$b"]}, vps),
+				result = expr.evaluate({a:2, b:1}),
+				expected = 1;
+			assert.strictEqual(result, expected);
+		},
+
+		"should return null if left is null": function() {
+			var idGenerator = new VariablesIdGenerator(),
+				vps = new VariablesParseState(idGenerator),
+				expr = Expression.parseOperand({$subtract:["$a", "$b"]}, vps),
+				result = expr.evaluate({a:null, b:1}),
+				expected = null;
+			assert.strictEqual(result, expected);
+		},
+
+		"should return null if left is undefined": function() {
+			var idGenerator = new VariablesIdGenerator(),
+				vps = new VariablesParseState(idGenerator),
+				expr = Expression.parseOperand({$subtract:["$a", "$b"]}, vps),
+				result = expr.evaluate({a:undefined, b:1}),
+				expected = null;
+			assert.strictEqual(result, expected);
+		},
+
+		"should return null if right is null": function() {
+			var idGenerator = new VariablesIdGenerator(),
+				vps = new VariablesParseState(idGenerator),
+				expr = Expression.parseOperand({$subtract:["$a", "$b"]}, vps),
+				result = expr.evaluate({a:2, b:null}),
+				expected = null;
+			assert.strictEqual(result, expected);
+		},
+
+		"should return null if right is undefined": function() {
+			var idGenerator = new VariablesIdGenerator(),
+				vps = new VariablesParseState(idGenerator),
+				expr = Expression.parseOperand({$subtract:["$a", "$b"]}, vps),
+				result = expr.evaluate({a:2, b:undefined}),
+				expected = null;
+			assert.strictEqual(result, expected);
+		},
+
+		"should subtract 2 dates": function() {
+			var idGenerator = new VariablesIdGenerator(),
+				vps = new VariablesParseState(idGenerator),
+				expr = Expression.parseOperand({$subtract:["$a", "$b"]}, vps),
+				date2 = new Date("Jan 3 1990"),
+				date1 = new Date("Jan 1 1990"),
+				result = expr.evaluate({a:date2, b:date1}),
+				expected = date2 - date1;
+			assert.strictEqual(result, expected);
+		},
+
+		"should subtract a number of millis from a date": function() {
+			var idGenerator = new VariablesIdGenerator(),
+				vps = new VariablesParseState(idGenerator),
+				expr = Expression.parseOperand({$subtract:["$a", "$b"]}, vps),
+				date2 = new Date("Jan 3 1990"),
+				millis = 24 * 60 * 60 * 1000,
+				result = expr.evaluate({a:date2, b:millis}),
+				expected = date2 - millis;
+			assert.strictEqual(
+				JSON.stringify(result),
+				JSON.stringify(expected)
+			);
+		},
+
+		"should throw if left is not a date or number": function() {
+			var idGenerator = new VariablesIdGenerator(),
+				vps = new VariablesParseState(idGenerator),
+				expr = Expression.parseOperand({$subtract:["$a", "$b"]}, vps),
+				date2 = {},
+				date1 = new Date();
+			assert.throws(function() {
+				expr.evaluate({a:date2, b:date1});
+			});
+		},
+
+		"should throw if right is not a date or number": function() {
+			var idGenerator = new VariablesIdGenerator(),
+				vps = new VariablesParseState(idGenerator),
+				expr = Expression.parseOperand({$subtract:["$a", "$b"]}, vps),
+				date2 = new Date(),
+				date1 = {};
+			assert.throws(function() {
+				expr.evaluate({a:date2, b:date1});
+			});
+		},
+
+	},
 
 };
 
-if (!module.parent)(new(require("mocha"))()).ui("exports").reporter("spec").addFile(__filename).run(process.exit);
+if (!module.parent)(new(require("mocha"))()).ui("exports").reporter("spec").addFile(__filename).run(process.exit);