EAGLESIX-2651: Object: make tests closer to 2.6.5 code

test/lib/pipeline/expressions/ObjectExpression.js

@@ -4,7 +4,8 @@ var assert = require("assert"),
 	ConstantExpression = require("../../../../lib/pipeline/expressions/ConstantExpression"),
 	FieldPathExpression = require("../../../../lib/pipeline/expressions/FieldPathExpression"),
 	AndExpression = require("../../../../lib/pipeline/expressions/AndExpression"),
-	Variables = require("../../../../lib/pipeline/expressions/Variables");
+	Variables = require("../../../../lib/pipeline/expressions/Variables"),
+	DepsTracker = require("../../../../lib/pipeline/DepsTracker");
 
 
 function assertEqualJson(actual, expected, message){
@@ -17,6 +18,17 @@ function assertEqualJson(actual, expected, message){
 	assert.strictEqual(message + ":  " + JSON.stringify(actual), message + ":  " + JSON.stringify(expected));
 }
 
+function assertDependencies(expectedDependencies, expression, includePath) {
+	if (includePath === undefined) includePath = true;
+	var path = [],
+		dependencies = new DepsTracker();
+	expression.addDependencies(dependencies, includePath ? path : undefined);
+	var bab = Object.keys(dependencies.fields);
+	assert.deepEqual(bab.sort(), expectedDependencies.sort());
+	assert.strictEqual(dependencies.needWholeDocument, false);
+	assert.strictEqual(dependencies.needTextScore, false);
+}
+
 /// An assertion for `ObjectExpression` instances based on Mongo's `ExpectedResultBase` class
 function assertExpectedResult(args) {
 	{// check for required args
@@ -27,21 +39,18 @@ function assertExpectedResult(args) {
 	}// check for required args
 	{// base args if none provided
 		if (args.source === undefined) args.source = {_id:0, a:1, b:2};
-		if (args.expectedIsSimple === undefined) args.expectedIsSimple = false;
+		if (args.expectedIsSimple === undefined) args.expectedIsSimple = true;
 		if (args.expression === undefined) args.expression = ObjectExpression.createRoot(); //NOTE: replaces prepareExpression + _expression assignment
 	}// base args if none provided
 	// run implementation
-	var result = {},
-		variable = new Variables(1, args.source);
-
-	args.expression.addToDocument(result, args.source, variable);
+	var doc = args.source,
+		result = {},
+		vars = new Variables(0, doc);
+	args.expression.addToDocument(result, doc, vars);
 	assert.deepEqual(result, args.expected);
-	var dependencies = {};
-	args.expression.addDependencies(dependencies, [/*FAKING: includePath=true*/]);
-	//dependencies.sort(), args.expectedDependencies.sort();	// NOTE: this is a minor hack added for munge because I'm pretty sure order doesn't matter for this anyhow
-	assert.deepEqual(Object.keys(dependencies).sort(), Object.keys(args.expectedDependencies).sort());
-	assert.deepEqual(args.expression.serialize(true), args.expectedJsonRepresentation);
-	assert.deepEqual(args.expression.getIsSimple(), args.expectedIsSimple);
+	assertDependencies(args.expectedDependencies, args.expression);
+	assert.deepEqual(args.expression.serialize(false), args.expectedJsonRepresentation);
+	assert.deepEqual(args.expression.isSimple(), args.expectedIsSimple);
 }
 
 
@@ -51,7 +60,7 @@ module.exports = {
 
 		"constructor()": {
 
-			"should not throw Error when constructing without args": function testConstructor(){
+			"should not throw Error when constructing without args": function(){
 				assert.doesNotThrow(function(){
 					ObjectExpression.create();
 				});
@@ -64,7 +73,7 @@ module.exports = {
 			"should be able to get dependencies for non-inclusion expressions": function testNonInclusionDependencies(){
 				/** Dependencies for non inclusion expressions. */
 				var expr = ObjectExpression.create();
-				expr.addField("a", new ConstantExpression(5));
+				expr.addField("a", ConstantExpression.create(5));
 				var depsTracker = {fields:{}};
 				assertEqualJson(expr.addDependencies(depsTracker, [/*FAKING: includePath=true*/]), {fields:{"_id":1}}, "Message");
 				expr.excludeId = true;
@@ -99,8 +108,8 @@ module.exports = {
 			"should be able to convert to JSON representation and have constants represented by expressions": function testJson(){
 				/** Serialize to a BSONObj, with constants represented by expressions. */
 				var expr = ObjectExpression.create(true);
-				expr.addField("foo.a", new ConstantExpression(5));
-				assertEqualJson({foo:{a:{$const:5}}}, expr.serialize(true));
+				expr.addField("foo.a", ConstantExpression.create(5));
+				assertEqualJson({foo:{a:{$const:5}}}, expr.serialize());
 			}
 
 		},
@@ -111,12 +120,12 @@ module.exports = {
 				/** Optimizing an object expression optimizes its sub expressions. */
 				var expr = ObjectExpression.createRoot();
 				// Add inclusion.
-				expr.includePath( "a" );
+				expr.includePath("a");
 				// Add non inclusion.
-				expr.addField( "b", new AndExpression());
+				expr.addField("b", new AndExpression());
 				expr.optimize();
 				// Optimizing 'expression' optimizes its non inclusion sub expressions, while inclusion sub expressions are passed through.
-				assertEqualJson({a:{$const:null}, b:{$const:true}}, expr.serialize(true));
+				assertEqualJson({a:true, b:{$const:true}}, expr.serialize());
 			}
 
 		},
@@ -128,8 +137,8 @@ module.exports = {
 				var expr = ObjectExpression.createRoot();
 				assertExpectedResult({
 					expression: expr,
-					expected: {"_id":0},
-					expectedDependencies: {"fields":1},
+					expected: {_id:0},
+					expectedDependencies: ["_id"],
 					expectedJsonRepresentation: {}
 				});
 			},
@@ -137,169 +146,169 @@ module.exports = {
 			"should be able to include 'a' field only": function testInclude(){
 				/** Include 'a' field only. */
 				var expr = ObjectExpression.createRoot();
-				expr.includePath( "a" );
+				expr.includePath("a");
 				assertExpectedResult({
 					expression: expr,
-					expected: {"_id":0, "a":1},
-					expectedDependencies: {"fields":{"_id":1, "a":1}},
-					expectedJsonRepresentation: {"a":{$const:null}}
+					expected: {_id:0, a:1},
+					expectedDependencies: ["_id", "a"],
+					expectedJsonRepresentation: {a:true}
 				});
 			},
 
 			"should NOT be able to include missing 'a' field": function testMissingInclude(){
 				/** Cannot include missing 'a' field. */
 				var expr = ObjectExpression.createRoot();
-				expr.includePath( "a" );
+				expr.includePath("a");
 				assertExpectedResult({
-					source: {"_id":0, "b":2},
+					source: {_id:0, b:2},
 					expression: expr,
-					expected: {"_id":0},
-					expectedDependencies: {"fields":{"_id":1, "a":1}},
-					expectedJsonRepresentation: {"a":{$const:null}}
+					expected: {_id:0},
+					expectedDependencies: ["_id", "a"],
+					expectedJsonRepresentation: {a:true}
 				});
 			},
 
 			"should be able to include '_id' field only": function testIncludeId(){
 				/** Include '_id' field only. */
 				var expr = ObjectExpression.createRoot();
-				expr.includePath( "_id" );
+				expr.includePath("_id");
 				assertExpectedResult({
 					expression: expr,
-					expected: {"_id":0},
-					expectedDependencies: {"fields":{"_id":1}},
-					expectedJsonRepresentation: {"_id":{$const:null}}
+					expected: {_id:0},
+					expectedDependencies: ["_id"],
+					expectedJsonRepresentation: {_id:true}
 				});
 			},
 
 			"should be able to exclude '_id' field": function testExcludeId(){
 				/** Exclude '_id' field. */
 				var expr = ObjectExpression.createRoot();
-				expr.includePath( "b" );
+				expr.includePath("b");
 				expr.excludeId = true;
 				assertExpectedResult({
 					expression: expr,
-					expected: {"b":2},
-					expectedDependencies: {"fields":{"b":1}},
-					expectedJsonRepresentation: {"b":{$const:null}}
+					expected: {b:2},
+					expectedDependencies: ["b"],
+					expectedJsonRepresentation: {_id:false, b:true}
 				});
 			},
 
 			"should be able to include fields in source document order regardless of inclusion order": function testSourceOrder(){
 				/** Result order based on source document field order, not inclusion spec field order. */
 				var expr = ObjectExpression.createRoot();
-				expr.includePath( "b" );
-				expr.includePath( "a" );
+				expr.includePath("b");
+				expr.includePath("a");
 				assertExpectedResult({
 					expression: expr,
 					get expected() { return this.source; },
-					expectedDependencies: {"fields":{"_id":1, "a":1, "b":1}},
-					expectedJsonRepresentation: {"b":{$const:null}, "a":{$const:null}}
+					expectedDependencies: ["_id", "a", "b"],
+					expectedJsonRepresentation: {b:true, a:true}
 				});
 			},
 
 			"should be able to include a nested field": function testIncludeNested(){
 				/** Include a nested field. */
 				var expr = ObjectExpression.createRoot();
-				expr.includePath( "a.b" );
+				expr.includePath("a.b");
 				assertExpectedResult({
-					source: {"_id":0, "a":{ "b":5, "c":6}, "z":2 },
 					expression: expr,
-					expected: {"_id":0, "a":{ "b":5} },
-					expectedDependencies: {"fields":{"_id":1, "a.b":1}},
-					expectedJsonRepresentation: {"a":{ "b":{$const:null}} }
+					expected: {_id:0, a:{b:5}},
+					source: {_id:0, a:{b:5, c:6}, z:2},
+					expectedDependencies: ["_id", "a.b"],
+					expectedJsonRepresentation: {a:{b:true}}
 				});
 			},
 
 			"should be able to include two nested fields": function testIncludeTwoNested(){
 				/** Include two nested fields. */
 				var expr = ObjectExpression.createRoot();
-				expr.includePath( "a.b" );
-				expr.includePath( "a.c" );
+				expr.includePath("a.b");
+				expr.includePath("a.c");
 				assertExpectedResult({
-					source: {"_id":0, "a":{ "b":5, "c":6}, "z":2 },
 					expression: expr,
-					expected: {"_id":0, "a":{ "b":5, "c":6} },
-					expectedDependencies: {"fields":{"_id":1, "a.b":1, "a.c":1}},
-					expectedJsonRepresentation: {"a":{ "b":{$const:null}, "c":{$const:null}} }
+					expected: {_id:0, a:{b:5, c:6}},
+					source: {_id:0, a:{b:5,c:6}, z:2},
+					expectedDependencies: ["_id", "a.b", "a.c"],
+					expectedJsonRepresentation: {a:{b:true, c:true}}
 				});
 			},
 
 			"should be able to include two fields nested within different parents": function testIncludeTwoParentNested(){
 				/** Include two fields nested within different parents. */
 				var expr = ObjectExpression.createRoot();
-				expr.includePath( "a.b" );
-				expr.includePath( "c.d" );
+				expr.includePath("a.b");
+				expr.includePath("c.d");
 				assertExpectedResult({
-					source: {"_id":0, "a":{ "b":5 }, "c":{"d":6} },
 					expression: expr,
-					expected: {"_id":0, "a":{ "b":5}, "c":{"d":6} },
-					expectedDependencies: {"fields":{"_id":1, "a.b":1, "c.d":1}},
-					expectedJsonRepresentation: {"a":{"b":{$const:null}}, "c":{"d":{$const:null}} }
+					expected: {_id:0, a:{b:5}, c:{d:6}},
+					source: {_id:0, a:{b:5}, c:{d:6}, z:2},
+					expectedDependencies: ["_id", "a.b", "c.d"],
+					expectedJsonRepresentation: {a:{b:true}, c:{d:true}}
 				});
 			},
 
 			"should be able to attempt to include a missing nested field": function testIncludeMissingNested(){
 				/** Attempt to include a missing nested field. */
 				var expr = ObjectExpression.createRoot();
-				expr.includePath( "a.b" );
+				expr.includePath("a.b");
 				assertExpectedResult({
-					source: {"_id":0, "a":{ "c":6}, "z":2 },
 					expression: expr,
-					expected: {"_id":0, "a":{} },
-					expectedDependencies: {"fields":{"_id":1, "a.b":1}},
-					expectedJsonRepresentation: {"a":{ "b":{$const:null}} }
+					expected: {_id:0, a:{}},
+					source: {_id:0, a:{c:6}, z:2},
+					expectedDependencies: ["_id", "a.b"],
+					expectedJsonRepresentation: {a:{b:true}}
 				});
 			},
 
 			"should be able to attempt to include a nested field within a non object": function testIncludeNestedWithinNonObject(){
 				/** Attempt to include a nested field within a non object. */
 				var expr = ObjectExpression.createRoot();
-				expr.includePath( "a.b" );
+				expr.includePath("a.b");
 				assertExpectedResult({
-					source: {"_id":0, "a":2, "z":2},
 					expression: expr,
-					expected: {"_id":0},
-					expectedDependencies: {"fields":{"_id":1, "a.b":1}},
-					expectedJsonRepresentation: {"a":{ "b":{$const:null}} }
+					expected: {_id:0},
+					source: {_id:0, a:2, z:2},
+					expectedDependencies: ["_id", "a.b"],
+					expectedJsonRepresentation: {a:{b:true}}
 				});
 			},
 
 			"should be able to include a nested field within an array": function testIncludeArrayNested(){
 				/** Include a nested field within an array. */
 				var expr = ObjectExpression.createRoot();
-				expr.includePath( "a.b" );
+				expr.includePath("a.b");
 				assertExpectedResult({
-					source: {_id:0,a:[{b:5,c:6},{b:2,c:9},{c:7},[],2],z:1},
 					expression: expr,
 					expected: {_id:0,a:[{b:5},{b:2},{}]},
-					expectedDependencies: {"fields":{"_id":1, "a.b":1}},
-					expectedJsonRepresentation: {"a":{ "b":{$const:null}} }
+					source: {_id:0,a:[{b:5,c:6},{b:2,c:9},{c:7},[],2],z:1},
+					expectedDependencies: ["_id", "a.b"],
+					expectedJsonRepresentation: {a:{b:true}}
 				});
 			},
 
 			"should NOT include non-root '_id' field implicitly": function testExcludeNonRootId(){
 				/** Don't include not root '_id' field implicitly. */
 				var expr = ObjectExpression.createRoot();
-				expr.includePath( "a.b" );
+				expr.includePath("a.b");
 				assertExpectedResult({
-					source: {"_id":0, "a":{ "_id":1, "b":1} },
 					expression: expr,
-					expected: {"_id":0, "a":{ "b":1} },
-					expectedDependencies: {"fields":{"_id":1, "a.b":1}},
-					expectedJsonRepresentation: {"a":{ "b":{$const:null}}}
+					source: {_id:0, a:{_id:1, b:1}},
+					expected: {_id:0, a:{b:1}},
+					expectedDependencies: ["_id", "a.b"],
+					expectedJsonRepresentation: {a:{b:true}}
 				});
 			},
 
 			"should be able to project a computed expression": function testComputed(){
 				/** Project a computed expression. */
 				var expr = ObjectExpression.createRoot();
-				expr.addField("a", new ConstantExpression(5));
+				expr.addField("a", ConstantExpression.create(5));
 				assertExpectedResult({
-					source: {"_id":0},
 					expression: expr,
-					expected: {"_id":0, "a":5},
-					expectedDependencies: {"fields":{"_id":1}},
-					expectedJsonRepresentation: {"a":{ "$const":5} },
+					source: {_id:0},
+					expected: {_id:0, a:5},
+					expectedDependencies: ["_id"],
+					expectedJsonRepresentation: {a:{$const:5}},
 					expectedIsSimple: false
 				});
 			},
@@ -307,26 +316,26 @@ module.exports = {
 			"should be able to project a computed expression replacing an existing field": function testComputedReplacement(){
 				/** Project a computed expression replacing an existing field. */
 				var expr = ObjectExpression.createRoot();
-				expr.addField("a", new ConstantExpression(5));
+				expr.addField("a", ConstantExpression.create(5));
 				assertExpectedResult({
-					source: {"_id":0, "a":99},
 					expression: expr,
-					expected: {"_id": 0, "a": 5},
-					expectedDependencies: {"fields":{"_id":1}},
-					expectedJsonRepresentation: {"a": {"$const": 5}},
+					source: {_id:0, a:99},
+					expected: {_id:0, a:5},
+					expectedDependencies: ["_id"],
+					expectedJsonRepresentation: {a:{$const:5}},
 					expectedIsSimple: false
 				});
 			},
 
 			"should NOT be able to project an undefined value": function testComputedUndefined(){
-				/** An undefined value is not projected.. */
+				/** An undefined value is passed through */
 				var expr = ObjectExpression.createRoot();
-				expr.addField("a", new ConstantExpression(undefined));
+				expr.addField("a", ConstantExpression.create(undefined));
 				assertExpectedResult({
-					source: {"_id":0},
 					expression: expr,
-					expected: {"_id":0},
-					expectedDependencies: {"fields":{"_id":1}},
+					source: {_id:0},
+					expected: {_id:0, a:undefined},
+					expectedDependencies: ["_id"],
 					expectedJsonRepresentation: {a:{$const:undefined}},
 					expectedIsSimple: false
 				});
@@ -335,13 +344,13 @@ module.exports = {
 			"should be able to project a computed expression replacing an existing field with Undefined": function testComputedUndefinedReplacement(){
 				/** Project a computed expression replacing an existing field with Undefined. */
 				var expr = ObjectExpression.createRoot();
-				expr.addField("a", new ConstantExpression(5));
+				expr.addField("a", ConstantExpression.create(5));
 				assertExpectedResult({
-					source: {"_id":0, "a":99},
 					expression: expr,
-					expected: {"_id":0, "a":5},
-					expectedDependencies: {"fields":{"_id":1}},
-					expectedJsonRepresentation: {"a":{"$const":5}},
+					source: {_id:0, a:99},
+					expected: {_id:0, a:undefined},
+					expectedDependencies: ["_id"],
+					expectedJsonRepresentation: {a:{$const:undefined}},
 					expectedIsSimple: false
 				});
 			},
@@ -349,13 +358,13 @@ module.exports = {
 			"should be able to project a null value": function testComputedNull(){
 				/** A null value is projected. */
 				var expr = ObjectExpression.createRoot();
-				expr.addField("a", new ConstantExpression(null));
+				expr.addField("a", ConstantExpression.create(null));
 				assertExpectedResult({
-					source: {"_id":0},
 					expression: expr,
-					expected: {"_id":0, "a":null},
-					expectedDependencies: {"fields":{"_id":1}},
-					expectedJsonRepresentation: {"a":{"$const":null}},
+					source: {_id:0},
+					expected: {_id:0, a:null},
+					expectedDependencies: ["_id"],
+					expectedJsonRepresentation: {a:{$const:null}},
 					expectedIsSimple: false
 				});
 			},
@@ -363,13 +372,13 @@ module.exports = {
 			"should be able to project a nested value": function testComputedNested(){
 				/** A nested value is projected. */
 				var expr = ObjectExpression.createRoot();
-				expr.addField("a.b", new ConstantExpression(5));
+				expr.addField("a.b", ConstantExpression.create(5));
 				assertExpectedResult({
-					source: {"_id":0},
 					expression: expr,
-					expected: {"_id":0, "a":{"b":5}},
-					expectedDependencies: {"fields":{"_id":1}},
-					expectedJsonRepresentation: {"a":{"b":{"$const":5}}},
+					source: {_id:0},
+					expected: {_id:0, a:{b:5}},
+					expectedDependencies: ["_id"],
+					expectedJsonRepresentation: {a:{b:{$const:5}}},
 					expectedIsSimple: false
 				});
 			},
@@ -379,11 +388,11 @@ module.exports = {
 				var expr = ObjectExpression.createRoot();
 				expr.addField("a", FieldPathExpression.create("x"));
 				assertExpectedResult({
-					source: {"_id":0, "x":4},
 					expression: expr,
-					expected: {"_id":0, "a":4},
-					expectedDependencies: {"fields":{"_id":1, "x":1}},
-					expectedJsonRepresentation: {"a":"$x"},
+					source: {_id:0, x:4},
+					expected: {_id:0, a:4},
+					expectedDependencies: ["_id", "x"],
+					expectedJsonRepresentation: {a:"$x"},
 					expectedIsSimple: false
 				});
 			},
@@ -393,11 +402,11 @@ module.exports = {
 				var expr = ObjectExpression.createRoot();
 				expr.addField("a.b", FieldPathExpression.create("x.y"));
 				assertExpectedResult({
-					source: {"_id":0, "x":{"y":4}},
 					expression: expr,
-					expected: {"_id":0, "a":{"b":4}},
-					expectedDependencies: {"fields":{"_id":1, "x.y":1}},
-					expectedJsonRepresentation: {"a":{"b":"$x.y"}},
+					source: {_id:0, x:{y:4}},
+					expected: {_id:0, a:{b:4}},
+					expectedDependencies: ["_id", "x,y"],
+					expectedJsonRepresentation: {a:{b:"$x.y"}},
 					expectedIsSimple: false
 				});
 			},
@@ -408,12 +417,12 @@ module.exports = {
 				// Create a sub expression returning an empty object.
 				var subExpr = ObjectExpression.create();
 				subExpr.addField("b", FieldPathExpression.create("a.b"));
-				expr.addField( "a", subExpr );
+				expr.addField("a", subExpr);
 				assertExpectedResult({
-					source: {"_id":0},
 					expression: expr,
-					expected: {"_id":0},
-					expectedDependencies: {"fields":{"_id":1, 'a.b':1}},
+					source: {_id:0},
+					expected: {_id:0},
+					expectedDependencies: ["_id", "a.b"],
 					expectedJsonRepresentation: {a:{b:"$a.b"}},
 					expectedIsSimple: false
 				});
@@ -424,13 +433,13 @@ module.exports = {
 				var expr = ObjectExpression.createRoot();
 				// Create a sub expression returning an empty object.
 				var subExpr = ObjectExpression.create();
-				subExpr.addField("b", new ConstantExpression(6));
-				expr.addField( "a", subExpr );
+				subExpr.addField("b", ConstantExpression.create(6));
+				expr.addField("a", subExpr);
 				assertExpectedResult({
-					source: {"_id":0},
 					expression: expr,
-					expected: {"_id":0, "a":{ "b":6} },
-					expectedDependencies: {"fields":{"_id":1}},
+					source: {_id:0},
+					expected: {_id:0, a:{b:6}},
+					expectedDependencies: ["_id"],
 					expectedJsonRepresentation: {a:{b:{$const:6}}},
 					expectedIsSimple: false
 				});
@@ -439,13 +448,13 @@ module.exports = {
 			"should be able to project two computed fields within a common parent": function testAdjacentDottedComputedFields(){
 				/** Two computed fields within a common parent. */
 				var expr = ObjectExpression.createRoot();
-				expr.addField("a.b", new ConstantExpression(6));
-				expr.addField("a.c", new ConstantExpression(7));
+				expr.addField("a.b", ConstantExpression.create(6));
+				expr.addField("a.c", ConstantExpression.create(7));
 				assertExpectedResult({
-					source: {"_id":0},
 					expression: expr,
-					expected: {"_id":0, "a":{ "b":6, "c":7} },
-					expectedDependencies: {"fields":{"_id":1}},
+					source: {_id:0},
+					expected: {_id:0, a:{b:6, c:7}},
+					expectedDependencies: ["_id"],
 					expectedJsonRepresentation: {a:{b:{$const:6},c:{$const:7}}},
 					expectedIsSimple: false
 				});
@@ -454,15 +463,15 @@ module.exports = {
 			"should be able to project two computed fields within a common parent (w/ one case dotted)": function testAdjacentDottedAndNestedComputedFields(){
 				/** Two computed fields within a common parent, in one case dotted. */
 				var expr = ObjectExpression.createRoot();
-				expr.addField("a.b", new ConstantExpression(6));
+				expr.addField("a.b", ConstantExpression.create(6));
 				var subExpr = ObjectExpression.create();
-				subExpr.addField("c", new ConstantExpression( 7 ) );
+				subExpr.addField("c", ConstantExpression.create(7));
 				expr.addField("a", subExpr);
 				assertExpectedResult({
-					source: {"_id":0},
 					expression: expr,
-					expected: {"_id":0, "a":{ "b":6, "c":7} },
-					expectedDependencies: {"fields":{"_id":1}},
+					source: {_id:0},
+					expected: {_id:0, a:{b:6, c:7}},
+					expectedDependencies: ["_id"],
 					expectedJsonRepresentation: {a:{b:{$const:6},c:{$const:7}}},
 					expectedIsSimple: false
 				});
@@ -472,14 +481,14 @@ module.exports = {
 				/** Two computed fields within a common parent, in another case dotted. */
 				var expr = ObjectExpression.createRoot();
 				var subExpr = ObjectExpression.create();
-				subExpr.addField("b", new ConstantExpression(6));
-				expr.addField("a", subExpr );
-				expr.addField("a.c", new ConstantExpression(7));
+				subExpr.addField("b", ConstantExpression.create(6));
+				expr.addField("a", subExpr);
+				expr.addField("a.c", ConstantExpression.create(7));
 				assertExpectedResult({
-					source: {"_id":0},
 					expression: expr,
-					expected: {"_id":0, "a":{ "b":6, "c":7} },
-					expectedDependencies: {"fields":{"_id":1}},
+					source: {_id:0},
+					expected: {_id:0, a:{b:6, c:7}},
+					expectedDependencies: ["_id"],
 					expectedJsonRepresentation: {a:{b:{$const:6},c:{$const:7}}},
 					expectedIsSimple: false
 				});
@@ -489,16 +498,16 @@ module.exports = {
 				/** Two computed fields within a common parent, nested rather than dotted. */
 				var expr = ObjectExpression.createRoot();
 				var subExpr1 = ObjectExpression.create();
-				subExpr1.addField("b", new ConstantExpression(6));
+				subExpr1.addField("b", ConstantExpression.create(6));
 				expr.addField("a", subExpr1);
 				var subExpr2 = ObjectExpression.create();
-				subExpr2.addField("c", new ConstantExpression(7));
+				subExpr2.addField("c", ConstantExpression.create(7));
 				expr.addField("a", subExpr2);
 				assertExpectedResult({
-					source: {"_id":0},
 					expression: expr,
-					expected: {"_id":0, "a":{ "b":6, "c":7} },
-					expectedDependencies: {"fields":{"_id":1}},
+					source: {_id:0},
+					expected: {_id:0, a:{b:6, c:7}},
+					expectedDependencies: ["_id"],
 					expectedJsonRepresentation: {a:{b:{$const:6},c:{$const:7}}},
 					expectedIsSimple: false
 				});
@@ -507,17 +516,17 @@ module.exports = {
 			"should be able to project multiple nested fields out of order without affecting output order": function testAdjacentNestedOrdering(){
 				/** Field ordering is preserved when nested fields are merged. */
 				var expr = ObjectExpression.createRoot();
-				expr.addField("a.b", new ConstantExpression(6));
+				expr.addField("a.b", ConstantExpression.create(6));
 				var subExpr = ObjectExpression.create();
 				// Add field 'd' then 'c'.  Expect the same field ordering in the result doc.
-				subExpr.addField("d", new ConstantExpression(7));
-				subExpr.addField("c", new ConstantExpression(8));
+				subExpr.addField("d", ConstantExpression.create(7));
+				subExpr.addField("c", ConstantExpression.create(8));
 				expr.addField("a", subExpr);
 				assertExpectedResult({
-					source: {"_id":0},
 					expression: expr,
-					expected: {"_id":0, "a":{ "b":6, "d":7, "c":8} },
-					expectedDependencies: {"fields":{"_id":1}},
+					source: {_id:0},
+					expected: {_id:0, a:{b:6, d:7, c:8}},
+					expectedDependencies: ["_id"],
 					expectedJsonRepresentation: {a:{b:{$const:6},d:{$const:7},c:{$const:8}}},
 					expectedIsSimple: false
 				});
@@ -526,29 +535,28 @@ module.exports = {
 			"should be able to project adjacent fields two levels deep": function testMultipleNestedFields(){
 				/** Adjacent fields two levels deep. */
 				var expr = ObjectExpression.createRoot();
-				expr.addField("a.b.c", new ConstantExpression(6));
+				expr.addField("a.b.c", ConstantExpression.create(6));
 				var bSubExpression = ObjectExpression.create();
-				bSubExpression.addField("d", new ConstantExpression(7));
+				bSubExpression.addField("d", ConstantExpression.create(7));
 				var aSubExpression = ObjectExpression.create();
 				aSubExpression.addField("b", bSubExpression);
 				expr.addField("a", aSubExpression);
 				assertExpectedResult({
-					source:{_id:0},
 					expression: expr,
-					expected: {"_id":0, "a":{ "b":{ "c":6, "d":7}}},
-					expectedDependencies: {"fields":{_id:1}},
-					expectedJsonRepresentation:{"a":{"b":{"c":{$const:6},"d":{$const:7}}}},
-					expectedIsSimple:false
+					source: {_id:0},
+					expected: {_id:0, a:{b:{c:6, d:7}}},
+					expectedDependencies: ["_id"],
+					expectedJsonRepresentation: {a:{b:{c:{$const:6},d:{$const:7}}}},
+					expectedIsSimple: false
 				});
-				var res = expr.evaluateDocument(new Variables(1, {_id:1}));
 			},
 
 			"should throw an Error if two expressions generate the same field": function testConflictingExpressionFields(){
 				/** Two expressions cannot generate the same field. */
 				var expr = ObjectExpression.createRoot();
-				expr.addField("a", new ConstantExpression(5));
+				expr.addField("a", ConstantExpression.create(5));
 				assert.throws(function(){
-					expr.addField("a", new ConstantExpression(6)); // Duplicate field.
+					expr.addField("a", ConstantExpression.create(6)); // Duplicate field.
 				}, Error);
 			},
 
@@ -557,14 +565,14 @@ module.exports = {
 				var expr = ObjectExpression.createRoot();
 				expr.includePath("a");
 				assert.throws(function(){
-					expr.addField("a", new ConstantExpression(6));
+					expr.addField("a", ConstantExpression.create(6));
 				}, Error);
 			},
 
 			"should throw an Error if an inclusion field conflicts with an expression field": function testConflictingExpressionInclusionFields(){
 				/** An inclusion field conflicts with an expression field. */
 				var expr = ObjectExpression.createRoot();
-				expr.addField("a", new ConstantExpression(5));
+				expr.addField("a", ConstantExpression.create(5));
 				assert.throws(function(){
 					expr.includePath("a");
 				}, Error);
@@ -577,14 +585,14 @@ module.exports = {
 				subExpr.includePath("b");
 				expr.addField("a", subExpr);
 				assert.throws(function(){
-					expr.addField("a.b", new ConstantExpression(6));
+					expr.addField("a.b", ConstantExpression.create(6));
 				}, Error);
 			},
 
 			"should throw an Error if a constant expression conflicts with an object expression": function testConflictingConstantObjectExpressionFields(){
 				/** A constant expression conflicts with an object expression. */
 				var expr = ObjectExpression.createRoot();
-				expr.addField("a.b", new ConstantExpression(6));
+				expr.addField("a.b", ConstantExpression.create(6));
 				var subExpr = ObjectExpression.create();
 				subExpr.includePath("b");
 				assert.throws(function(){
@@ -595,27 +603,27 @@ module.exports = {
 			"should throw an Error if two nested expressions cannot generate the same field": function testConflictingNestedFields(){
 				/** Two nested expressions cannot generate the same field. */
 				var expr = ObjectExpression.createRoot();
-				expr.addField("a.b", new ConstantExpression(5));
+				expr.addField("a.b", ConstantExpression.create(5));
 				assert.throws(function(){
-					expr.addField("a.b", new ConstantExpression(6));	// Duplicate field.
+					expr.addField("a.b", ConstantExpression.create(6));	// Duplicate field.
 				}, Error);
 			},
 
 			"should throw an Error if an expression is created for a subfield of another expression": function testConflictingFieldAndSubfield(){
 				/** An expression cannot be created for a subfield of another expression. */
 				var expr = ObjectExpression.createRoot();
-				expr.addField("a", new ConstantExpression(5));
+				expr.addField("a", ConstantExpression.create(5));
 				assert.throws(function(){
-					expr.addField("a.b", new ConstantExpression(5));
+					expr.addField("a.b", ConstantExpression.create(5));
 				}, Error);
 			},
 
 			"should throw an Error if an expression is created for a nested field of another expression.": function testConflictingFieldAndNestedField(){
 				/** An expression cannot be created for a nested field of another expression. */
 				var expr = ObjectExpression.createRoot();
-				expr.addField("a", new ConstantExpression(5));
+				expr.addField("a", ConstantExpression.create(5));
 				var subExpr = ObjectExpression.create();
-				subExpr.addField("b", new ConstantExpression(5));
+				subExpr.addField("b", ConstantExpression.create(5));
 				assert.throws(function(){
 					expr.addField("a", subExpr);
 				}, Error);
@@ -624,9 +632,9 @@ module.exports = {
 			"should throw an Error if an expression is created for a parent field of another expression": function testConflictingSubfieldAndField(){
 				/** An expression cannot be created for a parent field of another expression. */
 				var expr = ObjectExpression.createRoot();
-				expr.addField("a.b", new ConstantExpression(5));
+				expr.addField("a.b", ConstantExpression.create(5));
 				assert.throws(function(){
-					expr.addField("a", new ConstantExpression(5));
+					expr.addField("a", ConstantExpression.create(5));
 				}, Error);
 			},
 
@@ -634,10 +642,10 @@ module.exports = {
 				/** An expression cannot be created for a parent of a nested field. */
 				var expr = ObjectExpression.createRoot();
 				var subExpr = ObjectExpression.create();
-				subExpr.addField("b", new ConstantExpression(5));
+				subExpr.addField("b", ConstantExpression.create(5));
 				expr.addField("a", subExpr);
 				assert.throws(function(){
-					expr.addField("a", new ConstantExpression(5));
+					expr.addField("a", ConstantExpression.create(5));
 				}, Error);
 			},
 
@@ -649,7 +657,7 @@ module.exports = {
 				 */
 				var expr = ObjectExpression.createRoot();
 				expr.includePath("a");
-				expr.addField("b", new ConstantExpression(5));
+				expr.addField("b", ConstantExpression.create(5));
 				expr.addField("c", FieldPathExpression.create("a"));
 				var res = expr.evaluateInternal(new Variables(1, {_id:0, a:1}));
 				assert.deepEqual({"b":5, "c":1}, res);
@@ -660,4 +668,4 @@ module.exports = {
 
 };
 
-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);