simplify test by comparing actual AST to expected AST

Author: csantero

node-tests/addon-tests/addon-test.js

@@ -32,37 +32,42 @@ describe('ember-cli-addon-tests (slow)', function() {
     return request('http://localhost:49741/assets/ts1.js')
       .then(response => {
         expect(response.statusCode).to.equal(200);
-        let parsed = esprima.parseScript(response.body);
-        let bodyStatements = parsed.body
-          .filter((s) => {
-            return s.type === 'ExpressionStatement';
-          })
-          .map((s) => s.expression)
-          .filter((s) =>
-              s.type === 'CallExpression' &&
-              s.callee.type === 'Identifier' &&
-              s.callee.name === 'define' &&
-              s.arguments &&
-              s.arguments[0] &&
-              s.arguments[0].type === 'Literal' &&
-              s.arguments[0].value === 'ts1/add')
-          .map((s) => s.arguments[2].body.body)[0];
 
-        let functionDeclaration = bodyStatements.filter((s) => s.type === 'FunctionDeclaration')[0];
-        expect(functionDeclaration.id.name).to.equal('add');
-        expect(functionDeclaration.body.body.length).to.equal(1);
-        expect(functionDeclaration.body.body[0].type).to.equal('ReturnStatement');
-        expect(functionDeclaration.params.length).to.equal(2);
-        expect(functionDeclaration.params[0].name).to.equal('a');
-        expect(functionDeclaration.params[1].name).to.equal('b');
+        let moduleBody = extractModuleBody(response.body, 'ts1/add');
+        assertModuleBody(moduleBody, `
+          "use strict";
 
-        let returnArgument = functionDeclaration.body.body[0].argument;
-        expect(returnArgument.type).to.equal('BinaryExpression');
-        expect(returnArgument.operator).to.equal('+');
-        expect(returnArgument.left.type).to.equal('Identifier');
-        expect(returnArgument.left.name).to.equal('a');
-        expect(returnArgument.right.type).to.equal('Identifier');
-        expect(returnArgument.right.name).to.equal('b');
+          Object.defineProperty(exports, "__esModule", {
+              value: true
+          });
+          exports.add = add;
+          function add(a, b) {
+              return a + b;
+          }
+        `);
       });
   });
 });
+
+function extractModuleBody(responseJs, moduleName) {
+  let parsed = esprima.parseScript(responseJs);
+  return parsed.body
+    .filter((s) => {
+      return s.type === 'ExpressionStatement';
+    })
+    .map((s) => s.expression)
+    .filter((s) =>
+        s.type === 'CallExpression' &&
+        s.callee.type === 'Identifier' &&
+        s.callee.name === 'define' &&
+        s.arguments &&
+        s.arguments[0] &&
+        s.arguments[0].type === 'Literal' &&
+        s.arguments[0].value === moduleName)
+    .map((s) => s.arguments[2].body)[0];
+}
+
+function assertModuleBody(actualParsed, expectedJs) {
+  let expectedParsed = esprima.parseScript(expectedJs);
+  expect(actualParsed.body).to.deep.equal(expectedParsed.body);
+}