Tracked tests

packages/ember-metal/tests/tracked/computed_test.js → packages/ember-metal/tests/tracked/computed_test.ts

@@ -1,25 +1,23 @@
-import { createWithDescriptors } from './support';
 import { get, set, tracked } from '../..';
 
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
 import { EMBER_METAL_TRACKED_PROPERTIES } from '@ember/canary-features';
+import { AbstractTestCase, moduleFor } from 'internal-test-helpers';
 
 if (EMBER_METAL_TRACKED_PROPERTIES) {
   moduleFor(
-    'tracked getters',
+    '@tracked getters',
     class extends AbstractTestCase {
       ['@test works without get'](assert) {
         let count = 0;
 
         class Count {
+          @tracked
           get foo() {
             count++;
             return `computed foo`;
           }
         }
 
-        tracked(Count.prototype, 'foo', Object.getOwnPropertyDescriptor(Count.prototype, 'foo'));
-
         let obj = new Count();
 
         assert.equal(obj.foo, 'computed foo', 'should return value');
@@ -30,14 +28,13 @@ if (EMBER_METAL_TRACKED_PROPERTIES) {
         let count = 0;
 
         class Count {
+          @tracked
           get foo() {
             count++;
             return `computed foo`;
           }
         }
 
-        tracked(Count.prototype, 'foo', Object.getOwnPropertyDescriptor(Count.prototype, 'foo'));
-
         let obj = new Count();
 
         assert.equal(get(obj, 'foo'), 'computed foo', 'should return value');
@@ -47,16 +44,19 @@ if (EMBER_METAL_TRACKED_PROPERTIES) {
       ['@test defining computed property should invoke property on set'](assert) {
         let count = 0;
 
-        let obj = createWithDescriptors({
+        let obj = new class {
+          __foo = '';
+
+          @tracked
           get foo() {
             return this.__foo;
-          },
+          }
 
           set foo(value) {
             count++;
             this.__foo = `computed ${value}`;
-          },
-        });
+          }
+        }();
 
         assert.equal(set(obj, 'foo', 'bar'), 'bar', 'should return set value');
         assert.equal(count, 1, 'should have invoked computed property');

packages/ember-metal/tests/tracked/set_test.ts

@@ -0,0 +1,65 @@
+import { AbstractTestCase, moduleFor } from 'internal-test-helpers';
+import { get, set, setHasViews, tracked } from '../..';
+
+import { EMBER_METAL_TRACKED_PROPERTIES } from '@ember/canary-features';
+
+if (EMBER_METAL_TRACKED_PROPERTIES) {
+  const createObj = () => {
+    class Obj {
+      @tracked string = 'string';
+      @tracked number = 23;
+      @tracked boolTrue = true;
+      @tracked boolFalse = false;
+      @tracked nullValue = null;
+      @tracked undefinedValue = undefined;
+      constructor() {
+        this.string = 'string';
+        this.number = 23;
+        this.boolTrue = true;
+        this.boolFalse = false;
+        this.nullValue = null;
+        this.undefinedValue = undefined;
+      }
+    }
+
+    return new Obj();
+  };
+
+  moduleFor(
+    '@tracked set',
+    class extends AbstractTestCase {
+      teardown() {
+        setHasViews(() => false);
+      }
+
+      ['@test should set arbitrary properties on an object'](assert) {
+        let obj = createObj();
+
+        let newObj = new class {
+          @tracked undefinedValue = 'emberjs';
+
+          constructor() {
+            this.undefinedValue = 'emberjs';
+          }
+        }();
+
+        for (let key in obj) {
+          assert.equal(set(newObj, key, obj[key]), obj[key], 'should return value');
+          assert.equal(get(newObj, key), obj[key], 'should set value');
+        }
+      }
+
+      ['@test should set a number key on an object'](assert) {
+        let obj = new class {
+          @tracked 1 = 'original';
+          constructor() {
+            this[1] = 'original';
+          }
+        }();
+
+        set(obj, '1', 'first');
+        assert.equal(obj[1], 'first');
+      }
+    }
+  );
+}

packages/ember-metal/tests/tracked/support.js

@@ -1,30 +1,5 @@
 import { tracked } from '../..';
 
-export function createTracked(values, proto = {}) {
-  function Class() {
-    for (let prop in values) {
-      this[prop] = values[prop];
-    }
-  }
-
-  for (let prop in values) {
-    Object.defineProperty(
-      proto,
-      prop,
-      tracked(proto, prop, {
-        enumerable: true,
-        configurable: true,
-        writable: true,
-        value: values[prop],
-      })
-    );
-  }
-
-  Class.prototype = proto;
-
-  return new Class();
-}
-
 export function createWithDescriptors(values) {
   function Class() {}
 

packages/ember-metal/tests/tracked/validation_test.js → packages/ember-metal/tests/tracked/validation_test.ts

@@ -1,29 +1,28 @@
-import { computed, defineProperty, get, set, tracked } from '../..';
-
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-import { tagForProperty } from '../..';
+import { computed, defineProperty, get, set, tagForProperty, tracked } from '../..';
 
 import { EMBER_METAL_TRACKED_PROPERTIES } from '@ember/canary-features';
+import { AbstractTestCase, moduleFor } from 'internal-test-helpers';
 
 if (EMBER_METAL_TRACKED_PROPERTIES) {
   moduleFor(
-    'tracked get validation',
+    '@tracked get validation',
     class extends AbstractTestCase {
       [`@test validators for tracked getters with dependencies should invalidate when the dependencies invalidate`](
         assert
       ) {
         class Tracked {
-          constructor(first, last) {
+          @tracked first: string;
+          @tracked last: string;
+          constructor(first: string, last: string) {
             this.first = first;
             this.last = last;
           }
-        }
 
-        track(Tracked, ['first', 'last'], {
+          @tracked(['first', 'last'])
           get full() {
             return `${this.first} ${this.last}`;
-          },
-        });
+          }
+        }
 
         let obj = new Tracked('Tom', 'Dale');
 
@@ -49,17 +48,21 @@ if (EMBER_METAL_TRACKED_PROPERTIES) {
       [`@test interaction with Ember object model (tracked property depending on Ember property)`](
         assert
       ) {
+        interface NameInterface {
+          first: string;
+          last: string;
+        }
         class Tracked {
-          constructor(name) {
+          @tracked name: NameInterface;
+          constructor(name: NameInterface) {
             this.name = name;
           }
-        }
 
-        track(Tracked, ['name'], {
+          @tracked('name')
           get full() {
             return `${get(this.name, 'first')} ${get(this.name, 'last')}`;
-          },
-        });
+          }
+        }
 
         let tom = { first: 'Tom', last: 'Dale' };
 
@@ -88,7 +91,8 @@ if (EMBER_METAL_TRACKED_PROPERTIES) {
         assert
       ) {
         class EmberObject {
-          constructor(name) {
+          name: Name;
+          constructor(name: Name) {
             this.name = name;
           }
         }
@@ -103,14 +107,14 @@ if (EMBER_METAL_TRACKED_PROPERTIES) {
         );
 
         class Name {
-          constructor(first, last) {
+          @tracked first: string;
+          @tracked last: string;
+          constructor(first: string, last: string) {
             this.first = first;
             this.last = last;
           }
         }
 
-        track(Name, ['first', 'last']);
-
         let tom = new Name('Tom', 'Dale');
         let obj = new EmberObject(tom);
 
@@ -134,7 +138,7 @@ if (EMBER_METAL_TRACKED_PROPERTIES) {
         assert.equal(get(obj, 'full'), 'Thomas Dale');
         snapshot = tag.value();
 
-        // assert.equal(tag.validate(snapshot), true);
+        assert.equal(tag.validate(snapshot), true);
       }
 
       ['@test interaction with the Ember object model (paths going through tracked properties)'](