Convert moduleFor to module

Author: elwayman02

tests/integration/components/video-player-component-test.js

@@ -1,22 +1,21 @@
-import { moduleForComponent } from 'ember-qunit';
+import { module } from 'qunit';
+import { setupRenderingTest } from 'ember-qunit';
+import '@ember/test-helpers';
 import test from 'ember-sinon-qunit/test-support/test';
 import assertSinonInTestContext from '../../helpers/assert-sinon-in-test-context';
 
 const fooValue = 42;
 
-moduleForComponent(
-  'video-player',
-  'Deprecated | Integration | Component | video player',
-  {
-    integration: true,
-    beforeEach() {
-      this.foo = fooValue;
-    },
-  }
-);
+module('Deprecated | Integration | Component | video player', function (hooks) {
+  setupRenderingTest(hooks);
 
-assertSinonInTestContext(test);
+  hooks.beforeEach(function () {
+    this.foo = fooValue;
+  });
 
-test('preserving the context from the `beforeEach` hook', function (assert) {
-  assert.equal(this.foo, fooValue);
+  assertSinonInTestContext(test);
+
+  test('preserving the context from the `beforeEach` hook', function (assert) {
+    assert.equal(this.foo, fooValue);
+  });
 });

tests/unit/ember-sinon-qunit-test.js

@@ -9,72 +9,72 @@ let fooValue = 42;
 let origMethod;
 let obj;
 
-module('Deprecated | Unit | ember-sinon-qunit', {
-  beforeEach() {
+module('Deprecated | Unit | ember-sinon-qunit', function (hooks) {
+  hooks.beforeEach(function () {
     this.foo = fooValue;
 
     origMethod = () => {};
     obj = {
       method: origMethod,
     };
-  },
+  });
 
-  afterEach(assert) {
+  hooks.afterEach(function (assert) {
     assert.equal(obj.method, origMethod, 'stub was reset');
-  },
-});
+  });
 
-assertSinonInTestContext(test);
+  assertSinonInTestContext(test);
 
-const deprecateStub = sinon
-  .stub(Ember, 'deprecate')
-  .callsFake(function (unused, deprecateTest) {
-    if (deprecateTest !== false) {
-      throw new Error(
-        'Ember.deprecate should be called with 2nd argument `false`'
-      );
-    }
-  });
+  const deprecateStub = sinon
+    .stub(Ember, 'deprecate')
+    .callsFake(function (unused, deprecateTest) {
+      if (deprecateTest !== false) {
+        throw new Error(
+          'Ember.deprecate should be called with 2nd argument `false`'
+        );
+      }
+    });
 
-test('does not destroy context from beforeEach', function (assert) {
-  assert.equal(this.foo, fooValue);
-});
+  test('does not destroy context from beforeEach', function (assert) {
+    assert.equal(this.foo, fooValue);
+  });
 
-if (!deprecateStub.called) {
-  throw new Error('Ember.deprecate should be called');
-}
-deprecateStub.restore();
+  if (!deprecateStub.called) {
+    throw new Error('Ember.deprecate should be called');
+  }
+  deprecateStub.restore();
 
-test('async with assert.async()', function (assert) {
-  assert.expect(2);
-  this.stub(obj, 'method');
+  test('async with assert.async()', function (assert) {
+    assert.expect(2);
+    this.stub(obj, 'method');
 
-  const done = assert.async();
-  setTimeout(() => {
-    assert.notEqual(obj.method, origMethod, 'stub not reset yet');
-    done();
+    const done = assert.async();
+    setTimeout(() => {
+      assert.notEqual(obj.method, origMethod, 'stub not reset yet');
+      done();
+    });
   });
-});
 
-test('async with Promise', function (assert) {
-  assert.expect(2);
-  this.stub(obj, 'method');
+  test('async with Promise', function (assert) {
+    assert.expect(2);
+    this.stub(obj, 'method');
 
-  return resolve().then(() => {
-    assert.notEqual(obj.method, origMethod);
+    return resolve().then(() => {
+      assert.notEqual(obj.method, origMethod);
+    });
   });
-});
 
-test('async with Promise and assert.async()', function (assert) {
-  assert.expect(3);
-  this.stub(obj, 'method');
+  test('async with Promise and assert.async()', function (assert) {
+    assert.expect(3);
+    this.stub(obj, 'method');
 
-  return resolve().then(() => {
-    assert.notEqual(obj.method, origMethod, 'stub not reset yet');
-    const done = assert.async();
-    setTimeout(() => {
+    return resolve().then(() => {
       assert.notEqual(obj.method, origMethod, 'stub not reset yet');
-      done();
+      const done = assert.async();
+      setTimeout(() => {
+        assert.notEqual(obj.method, origMethod, 'stub not reset yet');
+        done();
+      });
     });
   });
 });

tests/unit/models/only-test.js

@@ -2,8 +2,8 @@ import { module } from 'qunit';
 import test from 'ember-sinon-qunit/test-support/test';
 import only from 'ember-sinon-qunit/test-support/only';
 
-module('Deprecated | Unit | Utils | only');
-
-test('can import only', function (assert) {
-  assert.equal(typeof only, 'function', 'can import `only');
+module('Deprecated | Unit | Utils | only', function () {
+  test('can import only', function (assert) {
+    assert.equal(typeof only, 'function', 'can import `only');
+  });
 });

tests/unit/models/user-test.js

@@ -1,24 +1,30 @@
-import { moduleForModel } from 'ember-qunit';
+import { module } from 'qunit';
+import { setupTest } from 'ember-qunit';
 import test from 'ember-sinon-qunit/test-support/test';
 import assertSinonInTestContext from '../../helpers/assert-sinon-in-test-context';
 
+import { run } from '@ember/runloop';
+
 const fooValue = 42;
 
-moduleForModel('user', 'Deprecated | Unit | Model | user', {
-  integration: true,
-  beforeEach() {
+module('Deprecated | Unit | Model | user', function (hooks) {
+  setupTest(hooks);
+
+  hooks.beforeEach(function () {
     this.foo = fooValue;
-  },
-});
+  });
 
-test('it exists', function (assert) {
-  let model = this.subject();
-  // let store = this.store();
-  assert.ok(!!model);
-});
+  test('it exists', function (assert) {
+    let model = run(() =>
+      this.owner.lookup('service:store').createRecord('user')
+    );
+    // let store = this.store();
+    assert.ok(!!model);
+  });
 
-assertSinonInTestContext(test);
+  assertSinonInTestContext(test);
 
-test('preserving the context from the `beforeEach` hook', function (assert) {
-  assert.equal(this.foo, fooValue);
+  test('preserving the context from the `beforeEach` hook', function (assert) {
+    assert.equal(this.foo, fooValue);
+  });
 });

tests/unit/routes/application-test.js

@@ -1,23 +1,25 @@
-import { moduleFor } from 'ember-qunit';
+import { module } from 'qunit';
+import { setupTest } from 'ember-qunit';
 import test from 'ember-sinon-qunit/test-support/test';
 import assertSinonInTestContext from '../../helpers/assert-sinon-in-test-context';
 
 const fooValue = 42;
 
-moduleFor('route:application', 'Deprecated | Unit | Route | application', {
-  integration: true,
-  beforeEach() {
+module('Deprecated | Unit | Route | application', function (hooks) {
+  setupTest(hooks);
+
+  hooks.beforeEach(function () {
     this.foo = fooValue;
-  },
-});
+  });
 
-test('it exists', function (assert) {
-  let route = this.subject();
-  assert.ok(route);
-});
+  test('it exists', function (assert) {
+    let route = this.owner.lookup('route:application');
+    assert.ok(route);
+  });
 
-assertSinonInTestContext(test);
+  assertSinonInTestContext(test);
 
-test('preserving the context from the `beforeEach` hook', function (assert) {
-  assert.equal(this.foo, fooValue);
+  test('preserving the context from the `beforeEach` hook', function (assert) {
+    assert.equal(this.foo, fooValue);
+  });
 });