refactor typedef tests

Author: silesky

package.json

@@ -25,7 +25,7 @@
     "cjs": "tsc -p tsconfig.cjs.json",
     "run-example": "cd example && yarn && yarn dev",
     "clean": "rm -rf dist",
-    "lint": "eslint '**/*.{js,jsx,ts,tsx}'",
+    "lint": "tsc --noEmit && eslint '**/*.{js,jsx,ts,tsx}'",
     "prepare": "yarn pkg && husky install",
     "test": "jest"
   },

src/__tests__/analytics-pre-init.test.ts

@@ -78,79 +78,6 @@ describe('buffered class', () => {
   })
 })
 
-{
-  /* Type definintion tests */
-  ;async () => {
-    {
-      /* TEST: AnalyticsBuffered should return the correct type if awaited on */
-
-      // @ts-expect-error
-      await new AnalyticsBuffered(() => null)
-
-      const [analytics, context] = await new AnalyticsBuffered(
-        () => undefined as unknown as Promise<[Analytics, Context]>
-      )
-
-      const f: Analytics = analytics
-      // @ts-expect-error
-      analytics._SHOULD_ERR // check for any
-
-      const c: Context = context
-      // @ts-expect-error
-      c.SHOULD_ERR // check for any
-
-      console.log(f, c)
-    }
-    {
-      void new AnalyticsBuffered(
-        () => undefined as unknown as Promise<[Analytics, Context]>
-      )
-        .then(([analytics, context]) => {
-          // @ts-expect-error
-          analytics._SHOULD_ERR
-          // @ts-expect-error
-          context._SHOULD_ERR
-
-          const f: Analytics = analytics
-          // @ts-expect-error
-          analytics._SHOULD_ERR // check for any
-
-          const c: Context = context
-          // @ts-expect-error
-          c.SHOULD_ERR // check for any
-
-          console.log(f, c)
-        })
-        .then(() => {
-          return 'a String!'
-        })
-        .then((str) => {
-          /* TEST:  chaining multiple .thens should preserve type info */
-          // @ts-expect-error
-          str.SHOULD_ERR // check for any
-
-          const aString: string = str
-
-          console.log(aString)
-        })
-    }
-    {
-      /* TEST: if catch is before "then" in the middleware chain, should preserve type info */
-      void new AnalyticsBuffered(
-        () => undefined as unknown as Promise<[Analytics, Context]>
-      )
-        .catch((reason) => {
-          console.log(reason.SHOULD_NOT_ERR) // should be "any"
-          return 'a String'
-        })
-        .then((response) => {
-          const f: string | [Analytics, Context] = response // should return a union of either the "catch response" or "Analytics response"
-          console.log(f)
-        })
-    }
-  }
-}
-
 describe('callAnalyticsMethod', () => {
   let ajs!: Analytics
   let resolveSpy!: jest.Mock<any, any>

src/__tests__/test-helpers/type-assertions.ts

@@ -0,0 +1,15 @@
+type IsAny<T> = unknown extends T ? (T extends {} ? T : never) : never
+type NotAny<T> = T extends IsAny<T> ? never : T
+type NotUnknown<T> = unknown extends T ? never : T
+
+type NotTopType<T> = NotAny<T> & NotUnknown<T>
+
+// this is not meant to be run, just for type tests
+export function assertNotAny<T>(val: NotTopType<T>) {
+  console.log(val)
+}
+
+// this is not meant to be run, just for type tests
+export function assertIs<T extends SomeType, SomeType = any>(val: T) {
+  console.log(val)
+}

src/__tests__/typedef-tests/analytics-buffered.ts

@@ -0,0 +1,60 @@
+import { Analytics } from '@/analytics'
+import { AnalyticsBuffered } from '@/analytics-pre-init'
+import { Context } from '@/core/context'
+import { AnalyticsBrowser } from '../../browser'
+import { assertNotAny, assertIs } from '../test-helpers/type-assertions'
+
+export const __test = {
+  'Analytics should return AnalyticsBuffered': () => {
+    const result = AnalyticsBrowser.load({ writeKey: 'abc' })
+    assertNotAny(result)
+  },
+  'AnalyticsBuffered should return Promise<[Analytics, Context]> if awaited on.':
+    async () => {
+      // @ts-expect-error
+      await new AnalyticsBuffered(() => null)
+
+      const [analytics, context] = await new AnalyticsBuffered(
+        () => undefined as unknown as Promise<[Analytics, Context]>
+      )
+
+      assertNotAny(analytics)
+      assertIs<Analytics>(analytics)
+
+      assertNotAny(context)
+      assertIs<Context>(context)
+    },
+  'general type def test': () => {
+    /* Type definintion tests */
+    void new AnalyticsBuffered(
+      () => undefined as unknown as Promise<[Analytics, Context]>
+    )
+      .then(([analytics, context]) => {
+        assertNotAny(analytics)
+        assertIs<Analytics>(analytics)
+
+        assertNotAny(context)
+        assertIs<Context>(context)
+      })
+      .then(() => {
+        return 'a String!' as const
+      })
+      .then((str) => {
+        assertNotAny(str)
+        assertIs<'a String!'>(str)
+      })
+  },
+  'if catch is before "then" in the middleware chain, should preserve type info */':
+    () => {
+      void new AnalyticsBuffered(
+        () => undefined as unknown as Promise<[Analytics, Context]>
+      )
+        .catch(() => {
+          return 'a String'
+        })
+        .then((response) => {
+          assertNotAny(response)
+          assertIs<string | [Analytics, Context]>(response)
+        })
+    },
+}