Update tests (which worked as they should!)

tracked-tools · Sep 4, 2021 · 8e67fac · 8e67fac
1 parent eb78f04
commit 8e67fac
Show file tree

Hide file tree

Showing 4 changed files with 26 additions and 27 deletions.
diff --git a/tests/unit/helpers/load-test.ts b/tests/unit/helpers/load-test.ts
@@ -19,7 +19,7 @@ module("Unit | load", function (hooks) {
   });
 
   test("given a plain value", async function (assert) {
-    const result = load(12);
+    const result = load(12, this);
     assert.ok(
       result instanceof TrackedAsyncData,
       "it returns a TrackedAsyncData instance"

diff --git a/tests/unit/tracked-async-data-test.ts b/tests/unit/tracked-async-data-test.ts
@@ -9,14 +9,14 @@ module("Unit | TrackedAsyncData", function () {
     //   this fails both at the type-checking level and dynamically at runtime.
     class Subclass extends TrackedAsyncData<unknown> {}
 
-    assert.throws(() => new Subclass(Promise.resolve("nope")));
+    assert.throws(() => new Subclass(Promise.resolve("nope"), this));
   });
 
   test("is initially PENDING", async function (assert) {
     assert.expect(6);
     const deferred = defer();
 
-    const result = new TrackedAsyncData(deferred.promise);
+    const result = new TrackedAsyncData(deferred.promise, this);
     assert.equal(result.state, "PENDING");
     assert.equal(result.isPending, true);
     assert.equal(result.isResolved, false);
@@ -32,7 +32,7 @@ module("Unit | TrackedAsyncData", function () {
     assert.expect(6);
 
     const deferred = defer();
-    const result = new TrackedAsyncData(deferred.promise);
+    const result = new TrackedAsyncData(deferred.promise, this);
 
     deferred.resolve("foobar");
     await settled();
@@ -49,7 +49,7 @@ module("Unit | TrackedAsyncData", function () {
     test("undefined", async function (assert) {
       assert.expect(6);
 
-      const loadUndefined = new TrackedAsyncData(undefined);
+      const loadUndefined = new TrackedAsyncData(undefined, this);
       await settled();
 
       assert.equal(loadUndefined.state, "RESOLVED");
@@ -63,7 +63,7 @@ module("Unit | TrackedAsyncData", function () {
     test("null", async function (assert) {
       assert.expect(6);
 
-      const loadNull = new TrackedAsyncData(null);
+      const loadNull = new TrackedAsyncData(null, this);
       await settled();
 
       assert.equal(loadNull.state, "RESOLVED");
@@ -78,7 +78,7 @@ module("Unit | TrackedAsyncData", function () {
       assert.expect(6);
 
       const notAThenableObject = { notAThenable: true };
-      const loadObject = new TrackedAsyncData(notAThenableObject);
+      const loadObject = new TrackedAsyncData(notAThenableObject, this);
       await settled();
 
       assert.equal(loadObject.state, "RESOLVED");
@@ -92,7 +92,7 @@ module("Unit | TrackedAsyncData", function () {
     test("boolean: true", async function (assert) {
       assert.expect(6);
 
-      const loadTrue = new TrackedAsyncData(true);
+      const loadTrue = new TrackedAsyncData(true, this);
       await settled();
 
       assert.equal(loadTrue.state, "RESOLVED");
@@ -106,7 +106,7 @@ module("Unit | TrackedAsyncData", function () {
     test("boolean: false", async function (assert) {
       assert.expect(6);
 
-      const loadFalse = new TrackedAsyncData(false);
+      const loadFalse = new TrackedAsyncData(false, this);
       await settled();
 
       assert.equal(loadFalse.state, "RESOLVED");
@@ -120,7 +120,7 @@ module("Unit | TrackedAsyncData", function () {
     test("number", async function (assert) {
       assert.expect(6);
 
-      const loadNumber = new TrackedAsyncData(5);
+      const loadNumber = new TrackedAsyncData(5, this);
       await settled();
 
       assert.equal(loadNumber.state, "RESOLVED");
@@ -134,7 +134,7 @@ module("Unit | TrackedAsyncData", function () {
     test("string", async function (assert) {
       assert.expect(6);
 
-      const loadString = new TrackedAsyncData("js");
+      const loadString = new TrackedAsyncData("js", this);
       await settled();
 
       // loadString
@@ -152,7 +152,7 @@ module("Unit | TrackedAsyncData", function () {
 
     // This handles the error throw from rendering a rejected promise
     const deferred = defer();
-    const result = new TrackedAsyncData(deferred.promise);
+    const result = new TrackedAsyncData(deferred.promise, this);
 
     deferred.reject(new Error("foobar"));
     await deferred.promise.catch((error) => {
@@ -174,7 +174,7 @@ module("Unit | TrackedAsyncData", function () {
     assert.expect(2);
 
     const deferred = defer();
-    const result = new TrackedAsyncData(deferred.promise);
+    const result = new TrackedAsyncData(deferred.promise, this);
     assert.equal(result.state, "PENDING");
 
     deferred.resolve();
@@ -187,7 +187,7 @@ module("Unit | TrackedAsyncData", function () {
     assert.expect(3);
 
     const deferred = defer();
-    const result = new TrackedAsyncData(deferred.promise);
+    const result = new TrackedAsyncData(deferred.promise, this);
     assert.equal(result.state, "PENDING");
 
     deferred.reject(new Error("foobar"));

diff --git a/type-tests/load-test.ts b/type-tests/load-test.ts
@@ -4,10 +4,9 @@ import Load, { load } from "ember-async-data/helpers/load";
 import { expectTypeOf } from "expect-type";
 
 expectTypeOf(load).toEqualTypeOf<
-  <T>(data: T | Promise<T>, context?: object) => TrackedAsyncData<T>
+  <T>(data: T | Promise<T>, context: {}) => TrackedAsyncData<T>
 >();
 
-expectTypeOf(load(true)).toEqualTypeOf(new TrackedAsyncData(true));
 expectTypeOf(load(true, {})).toEqualTypeOf(new TrackedAsyncData(true, {}));
 
 interface PublicAPIForHelper<T> extends Helper {

diff --git a/type-tests/tracked-async-data-test.ts b/type-tests/tracked-async-data-test.ts
@@ -20,17 +20,17 @@ declare class PublicAPI<T> {
   toString(): string;
 }
 
-expectTypeOf(TrackedAsyncData).toBeConstructibleWith(12);
-expectTypeOf(TrackedAsyncData).toBeConstructibleWith("hello");
-expectTypeOf(TrackedAsyncData).toBeConstructibleWith(true);
-expectTypeOf(TrackedAsyncData).toBeConstructibleWith(null);
-expectTypeOf(TrackedAsyncData).toBeConstructibleWith(undefined);
-expectTypeOf(TrackedAsyncData).toBeConstructibleWith({ cool: "story" });
-expectTypeOf(TrackedAsyncData).toBeConstructibleWith(["neat"]);
-expectTypeOf(TrackedAsyncData).toBeConstructibleWith(Promise.resolve());
-expectTypeOf(TrackedAsyncData).toBeConstructibleWith(Promise.resolve(12));
-expectTypeOf(TrackedAsyncData).toBeConstructibleWith(Promise.reject());
-expectTypeOf(TrackedAsyncData).toBeConstructibleWith(Promise.reject("gah"));
+expectTypeOf(TrackedAsyncData).toBeConstructibleWith(12, {});
+expectTypeOf(TrackedAsyncData).toBeConstructibleWith("hello", {});
+expectTypeOf(TrackedAsyncData).toBeConstructibleWith(true, {});
+expectTypeOf(TrackedAsyncData).toBeConstructibleWith(null, {});
+expectTypeOf(TrackedAsyncData).toBeConstructibleWith(undefined, {});
+expectTypeOf(TrackedAsyncData).toBeConstructibleWith({ cool: "story" }, {});
+expectTypeOf(TrackedAsyncData).toBeConstructibleWith(["neat"], {});
+expectTypeOf(TrackedAsyncData).toBeConstructibleWith(Promise.resolve(), {});
+expectTypeOf(TrackedAsyncData).toBeConstructibleWith(Promise.resolve(12), {});
+expectTypeOf(TrackedAsyncData).toBeConstructibleWith(Promise.reject(), {});
+expectTypeOf(TrackedAsyncData).toBeConstructibleWith(Promise.reject("gah"), {});
 
 // We use `toMatchTypeOf` here to confirm the union type which makes up
 // `TrackedAsyncData` is structurally compatible with the desired public