Merge pull request #10 from cibernox/transform-subject

Implement this.subject transformation

Author: rwjblue

__testfixtures__/ember-qunit-codemod/subject.input.js

@@ -0,0 +1,57 @@
+import { moduleFor, test } from 'ember-qunit';
+
+moduleFor('service:flash', 'Unit | Service | Flash', {
+  unit: true
+});
+
+test('should allow messages to be queued', function (assert) {
+  let subject = this.subject();
+});
+
+moduleFor('service:non-singleton-service', 'Unit | Service | NonSingletonService', {
+  unit: true
+});
+
+test('does something', function (assert) {
+  let subject = this.subject({ name: 'James' });
+});
+
+moduleFor('model:foo', 'Unit | Model | Foo', {
+  unit: true
+});
+
+test('has some thing', function (assert) {
+  let subject = this.subject();
+});
+
+test('has another thing', function (assert) {
+  let subject = this.subject({ size: 'big' });
+});
+
+moduleForModel('foo', 'Integration | Model | Foo', {
+  integration: true
+});
+
+test('has some thing', function (assert) {
+  let subject = this.subject();
+});
+
+moduleForModel('foo', 'Unit | Model | Foo', {
+  needs: ['serializer:foo']
+});
+
+test('has some thing', function (assert) {
+  let subject = this.subject();
+});
+
+moduleForComponent('foo-bar', 'Unit | Component | FooBar', {
+  unit: true,
+});
+
+test('has some thing', function (assert) {
+  let subject = this.subject();
+});
+
+test('has another thing', function (assert) {
+  let subject = this.subject({ size: 'big' });
+});

__testfixtures__/ember-qunit-codemod/subject.output.js

@@ -0,0 +1,58 @@
+import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Service | Flash', function(hooks) {
+  setupTest(hooks);
+
+  test('should allow messages to be queued', function (assert) {
+    let subject = this.owner.lookup('service:flash');
+  });
+});
+
+module('Unit | Service | NonSingletonService', function(hooks) {
+  setupTest(hooks);
+
+  test('does something', function (assert) {
+    let subject = this.owner.factoryFor('service:non-singleton-service').create({ name: 'James' });
+  });
+});
+
+module('Unit | Model | Foo', function(hooks) {
+  setupTest(hooks);
+
+  test('has some thing', function (assert) {
+    let subject = this.owner.factoryFor('model:foo').create();
+  });
+
+  test('has another thing', function (assert) {
+    let subject = this.owner.factoryFor('model:foo').create({ size: 'big' });
+  });
+});
+
+module('Integration | Model | Foo', function(hooks) {
+  setupTest(hooks);
+
+  test('has some thing', function (assert) {
+    let subject = this.owner.factoryFor('model:foo').create();
+  });
+});
+
+module('Unit | Model | Foo', function(hooks) {
+  setupTest(hooks);
+
+  test('has some thing', function (assert) {
+    let subject = this.owner.factoryFor('model:foo').create();
+  });
+});
+
+module('Unit | Component | FooBar', function(hooks) {
+  setupTest(hooks);
+
+  test('has some thing', function (assert) {
+    let subject = this.owner.factoryFor('component:foo-bar').create();
+  });
+
+  test('has another thing', function (assert) {
+    let subject = this.owner.factoryFor('component:foo-bar').create({ size: 'big' });
+  });
+});

ember-qunit-codemod.js

@@ -104,7 +104,7 @@ module.exports = function(file, api, options) {
   function parseModule(p) {
     let calleeName = p.node.expression.callee.name;
     // Find the moduleName and the module's options
-    let moduleName, options;
+    let moduleName, subject, options;
     let calleeArguments = p.node.expression.arguments.slice();
     let lastArgument = calleeArguments[calleeArguments.length - 1];
     if (lastArgument.type === 'ObjectExpression') {
@@ -113,15 +113,23 @@ module.exports = function(file, api, options) {
     moduleName = calleeArguments[1] || calleeArguments[0];
 
     let setupIdentifier = 'setupTest';
-    if (calleeName === `moduleForComponent` && options) {
+    if (options) {
       let hasIntegration = options.properties.some(p => p.key.name === 'integration');
 
-      if (hasIntegration) {
-        setupIdentifier = 'setupRenderingTest';
+      if (calleeName === `moduleForComponent`) {
+        if (hasIntegration) {
+          setupIdentifier = 'setupRenderingTest';
+        } else {
+          subject = j.literal(`component:${calleeArguments[0].value}`);
+        }
+      } else if (calleeName === 'moduleForModel') {
+        subject = j.literal(`model:${calleeArguments[0].value}`);
+      } else if (!hasIntegration) {
+        subject = calleeArguments[0];
       }
     }
 
-    return [moduleName, options, setupIdentifier];
+    return [moduleName, options, setupIdentifier, subject];
   }
 
   function updateModuleForToNestedModule() {
@@ -147,7 +155,7 @@ module.exports = function(file, api, options) {
     }
 
     function createModule(p) {
-      let [moduleName, options, setupType] = parseModule(p);
+      let [moduleName, options, setupType, subject] = parseModule(p);
 
       // Create the new `module(moduleName, function(hooks) {});` invocation
       let callback = j.functionExpression(
@@ -178,7 +186,7 @@ module.exports = function(file, api, options) {
         });
       }
 
-      return [moduleInvocation, callback.body.body, setupType];
+      return [moduleInvocation, callback.body.body, setupType, subject];
     }
 
     function processRenderingTest(testExpression) {
@@ -219,23 +227,80 @@ module.exports = function(file, api, options) {
         });
     }
 
+    function processSubject(testExpression, subject) {
+      let thisDotSubjectUsage = j(testExpression).find(j.CallExpression, {
+        callee: {
+          type: 'MemberExpression',
+          object: {
+            type: 'ThisExpression',
+          },
+          property: {
+            name: 'subject',
+          },
+        },
+      });
+
+      if (thisDotSubjectUsage.size() === 0) {
+        return;
+      }
+
+      thisDotSubjectUsage.forEach(p => {
+        let options = p.node.arguments[0];
+        let subjectType = subject.value.split(':')[0];
+        let isSingletonSubject = !['model', 'component'].includes(subjectType);
+
+        // if we don't have `options` and the type is a singleton type
+        // use `this.owner.lookup(subject)`
+        if (!options && isSingletonSubject) {
+          p.replace(
+            j.callExpression(
+              j.memberExpression(
+                j.memberExpression(j.thisExpression(), j.identifier('owner')),
+                j.identifier('lookup')
+              ),
+              [subject]
+            )
+          );
+        } else {
+          p.replace(
+            j.callExpression(
+              j.memberExpression(
+                j.callExpression(
+                  j.memberExpression(
+                    j.memberExpression(j.thisExpression(), j.identifier('owner')),
+                    j.identifier('factoryFor')
+                  ),
+                  [subject]
+                ),
+                j.identifier('create')
+              ),
+              [options].filter(Boolean)
+            )
+          );
+        }
+      });
+    }
+
     let programPath = root.get('program');
     let bodyPath = programPath.get('body');
 
     let bodyReplacement = [];
-    let currentModuleCallbackBody, currentTestType;
+    let currentModuleCallbackBody, currentTestType, currentSubject;
     bodyPath.each(expressionPath => {
       let expression = expressionPath.node;
       if (isModuleDefinition(expressionPath)) {
         let result = createModule(expressionPath);
         bodyReplacement.push(result[0]);
         currentModuleCallbackBody = result[1];
         currentTestType = result[2];
+        currentSubject = result[3];
       } else if (currentModuleCallbackBody) {
         currentModuleCallbackBody.push(expression);
 
         if (currentTestType === 'setupRenderingTest') {
           processRenderingTest(expression);
+        } else if (currentTestType === 'setupTest') {
+          processSubject(expression, currentSubject);
         }
       } else {
         bodyReplacement.push(expression);