Adding deprecatedTest

packages/-ember-data/tests/helpers/deprecated-test.js

@@ -1,8 +1,18 @@
-// import { gte } from 'ember-compatibility-helpers';
 import { test } from 'qunit';
 import VERSION from 'ember-data/version';
 
-export function deprecatedTest(deprecation, testName, testCallback) {
+// small comparison function for major and minor semver values
+function gte(EDVersion, DeprecationVersion) {
+  let _edv = EDVersion.split('.');
+  let _depv = DeprecationVersion.split('.');
+  // compare major
+  let major = +_edv[0] >= +_depv[0];
+  // compare minor
+  let minor = +_edv[1] >= +_depv[1];
+  return major || minor;
+}
+
+export function deprecatedTest(testName, deprecation, testCallback) {
   // '4.0'
   if (typeof deprecation.until !== 'string' || deprecation.until.length < 3) {
     throw new Error(`deprecatedTest expects { until } to be a version.`);
@@ -11,14 +21,11 @@ export function deprecatedTest(deprecation, testName, testCallback) {
   if (typeof deprecation.id !== 'string' || deprecation.id.length < 8) {
     throw new Error(`deprecatedTest expects { id } to be a meaningful string`);
   }
-  // gte('ember-data', '3.12')
-  if (VERSION <= deprecation.until) {
-    return test(
-      `DEPRECATION ${deprecation.id} until ${deprecation.until} | ${testName}`,
-      testCallback
-    );
+
+  if (gte(VERSION, deprecation.until)) {
+    test(`DEPRECATION ${deprecation.id} until ${deprecation.until} | ${testName}`, testCallback);
   } else {
-    return test(`DEPRECATION ${deprecation.id} until ${
+    test(`DEPRECATION ${deprecation.id} until ${
       deprecation.until
     } | ${testName}`, function(assert) {
       if (deprecation.refactor === true) {

packages/-ember-data/tests/integration/lifecycle-hooks-test.js

@@ -1,8 +1,9 @@
 import { resolve } from 'rsvp';
 import { run } from '@ember/runloop';
+import { deprecatedTest } from 'dummy/tests/helpers/deprecated-test';
 import setupStore from 'dummy/tests/helpers/store';
 
-import { module, test } from 'qunit';
+import { module } from 'qunit';
 
 import DS from 'ember-data';
 
@@ -24,41 +25,55 @@ module('integration/lifecycle_hooks - Lifecycle Hooks', function(hooks) {
     run(env.container, 'destroy');
   });
 
-  test('When the adapter acknowledges that a record has been created, a `didCreate` event is triggered.', function(assert) {
-    let done = assert.async();
-    assert.expect(3);
-
-    env.adapter.createRecord = function(store, type, snapshot) {
-      return resolve({ data: { id: 99, type: 'person', attributes: { name: 'Yehuda Katz' } } });
-    };
-
-    let person = env.store.createRecord('person', { name: 'Yehuda Katz' });
-
-    person.on('didCreate', function() {
-      assert.equal(this, person, 'this is bound to the record');
-      assert.equal(this.get('id'), '99', 'the ID has been assigned');
-      assert.equal(this.get('name'), 'Yehuda Katz', 'the attribute has been assigned');
-      done();
-    });
-
-    run(person, 'save');
-  });
-
-  test('When the adapter acknowledges that a record has been created without a new data payload, a `didCreate` event is triggered.', function(assert) {
-    assert.expect(3);
-
-    env.adapter.createRecord = function(store, type, snapshot) {
-      return resolve();
-    };
-
-    let person = env.store.createRecord('person', { id: 99, name: 'Yehuda Katz' });
-
-    person.on('didCreate', function() {
-      assert.equal(this, person, 'this is bound to the record');
-      assert.equal(this.get('id'), '99', 'the ID has been assigned');
-      assert.equal(this.get('name'), 'Yehuda Katz', 'the attribute has been assigned');
-    });
-
-    run(person, 'save');
-  });
+  deprecatedTest(
+    'When the adapter acknowledges that a record has been created, a `didCreate` event is triggered.',
+    {
+      id: 'ember-evented',
+      until: '3.12',
+    },
+    function(assert) {
+      let done = assert.async();
+      assert.expect(3);
+
+      env.adapter.createRecord = function(store, type, snapshot) {
+        return resolve({ data: { id: 99, type: 'person', attributes: { name: 'Yehuda Katz' } } });
+      };
+
+      let person = env.store.createRecord('person', { name: 'Yehuda Katz' });
+
+      person.on('didCreate', function() {
+        assert.equal(this, person, 'this is bound to the record');
+        assert.equal(this.get('id'), '99', 'the ID has been assigned');
+        assert.equal(this.get('name'), 'Yehuda Katz', 'the attribute has been assigned');
+        done();
+      });
+
+      run(person, 'save');
+    }
+  );
+
+  deprecatedTest(
+    'When the adapter acknowledges that a record has been created without a new data payload, a `didCreate` event is triggered.',
+    {
+      id: 'ember-evented',
+      until: '3.12',
+    },
+    function(assert) {
+      assert.expect(3);
+
+      env.adapter.createRecord = function(store, type, snapshot) {
+        return resolve();
+      };
+
+      let person = env.store.createRecord('person', { id: 99, name: 'Yehuda Katz' });
+
+      person.on('didCreate', function() {
+        assert.equal(this, person, 'this is bound to the record');
+        assert.equal(this.get('id'), '99', 'the ID has been assigned');
+        assert.equal(this.get('name'), 'Yehuda Katz', 'the attribute has been assigned');
+      });
+
+      run(person, 'save');
+    }
+  );
 });

packages/-ember-data/tests/integration/relationships/has-many-test.js

@@ -6,6 +6,7 @@ import { get } from '@ember/object';
 import { run } from '@ember/runloop';
 import setupStore from 'dummy/tests/helpers/store';
 import testInDebug from 'dummy/tests/helpers/test-in-debug';
+import { deprecatedTest } from 'dummy/tests/helpers/deprecated-test';
 import { module, test, skip } from 'qunit';
 import { relationshipStateFor, relationshipsFor } from 'ember-data/-private';
 import DS from 'ember-data';
@@ -1266,71 +1267,78 @@ module('integration/relationships/has_many - Has-Many Relationships', function(h
     });
   });
 
-  test('PromiseArray proxies evented methods to its ManyArray', function(assert) {
-    assert.expect(6);
-
-    Post.reopen({
-      comments: DS.hasMany('comment', { async: true }),
-    });
+  deprecatedTest(
+    'PromiseArray proxies evented methods to its ManyArray',
+    {
+      id: 'ember-evented',
+      until: '3.12',
+    },
+    function(assert) {
+      assert.expect(6);
 
-    env.adapter.findHasMany = function(store, snapshot, link, relationship) {
-      return resolve({
-        data: [
-          { id: 1, type: 'comment', attributes: { body: 'First' } },
-          { id: 2, type: 'comment', attributes: { body: 'Second' } },
-        ],
+      Post.reopen({
+        comments: DS.hasMany('comment', { async: true }),
       });
-    };
-    let post, comments;
 
-    run(function() {
-      env.store.push({
-        data: {
-          type: 'post',
-          id: '1',
-          relationships: {
-            comments: {
-              links: {
-                related: 'someLink',
+      env.adapter.findHasMany = function(store, snapshot, link, relationship) {
+        return resolve({
+          data: [
+            { id: 1, type: 'comment', attributes: { body: 'First' } },
+            { id: 2, type: 'comment', attributes: { body: 'Second' } },
+          ],
+        });
+      };
+      let post, comments;
+
+      run(function() {
+        env.store.push({
+          data: {
+            type: 'post',
+            id: '1',
+            relationships: {
+              comments: {
+                links: {
+                  related: 'someLink',
+                },
               },
             },
           },
-        },
+        });
+        post = env.store.peekRecord('post', 1);
+        comments = post.get('comments');
       });
-      post = env.store.peekRecord('post', 1);
-      comments = post.get('comments');
-    });
 
-    comments.on('on-event', function() {
-      assert.ok(true);
-    });
+      comments.on('on-event', function() {
+        assert.ok(true);
+      });
 
-    run(function() {
-      comments.trigger('on-event');
-    });
+      run(function() {
+        comments.trigger('on-event');
+      });
 
-    assert.equal(comments.has('on-event'), true);
-    const cb = function() {
-      assert.ok(false, 'We should not trigger this event');
-    };
+      assert.equal(comments.has('on-event'), true);
+      const cb = function() {
+        assert.ok(false, 'We should not trigger this event');
+      };
 
-    comments.on('off-event', cb);
-    comments.off('off-event', cb);
+      comments.on('off-event', cb);
+      comments.off('off-event', cb);
 
-    assert.equal(comments.has('off-event'), false);
+      assert.equal(comments.has('off-event'), false);
 
-    comments.one('one-event', function() {
-      assert.ok(true);
-    });
+      comments.one('one-event', function() {
+        assert.ok(true);
+      });
 
-    assert.equal(comments.has('one-event'), true);
+      assert.equal(comments.has('one-event'), true);
 
-    run(function() {
-      comments.trigger('one-event');
-    });
+      run(function() {
+        comments.trigger('one-event');
+      });
 
-    assert.equal(comments.has('one-event'), false);
-  });
+      assert.equal(comments.has('one-event'), false);
+    }
+  );
 
   test('An updated `links` value should invalidate a relationship cache', function(assert) {
     assert.expect(8);