Include type-tests into regular compile process

See tsdjs/tsd#142
mittwald · Jul 14, 2023 · 639aecb · 639aecb
1 parent 8925001
commit 639aecb
Show file tree

Hide file tree

Showing 7 changed files with 166 additions and 109 deletions.
diff --git a/packages/commons/.npmignore b/packages/commons/.npmignore
@@ -0,0 +1 @@
+*.test-types.*
diff --git a/packages/commons/package.json b/packages/commons/package.json
@@ -25,8 +25,7 @@
     }
   },
   "scripts": {
-    "test": "yarn test:tsd",
-    "test:tsd": "pnpify run tsd"
+    "test": "echo 'No tests available'"
   },
   "files": [
     "dist/**/*.{js,d.ts}"

diff --git a/packages/commons/src/core/Request.test-types.ts b/packages/commons/src/core/Request.test-types.ts
@@ -0,0 +1,122 @@
+import { expectAssignable } from "tsd";
+import { RequestType } from "../types/index.js";
+
+type Data = { foo: string };
+type Path = { bar: string };
+type Header = { baz: string };
+
+function ignoredTestEmptyRequestTypes() {
+  expectAssignable<RequestType>({});
+  // @ts-expect-error Not assignable
+  expectAssignable<RequestType>({ extra: true });
+  // @ts-expect-error Not assignable
+  expectAssignable<RequestType>({ data: {} });
+  // @ts-expect-error Not assignable
+  expectAssignable<RequestType>({ data: null });
+  // @ts-expect-error Not assignable
+  expectAssignable<RequestType>({ pathParameters: {} });
+}
+
+function ignoredTestRequestTypesWithDataType() {
+  expectAssignable<RequestType<Data>>({ data: { foo: "" } });
+  // @ts-expect-error Not assignable
+  expectAssignable<RequestType<Data>>({});
+  expectAssignable<RequestType<Data>>({
+    // @ts-expect-error Not assignable
+    data: { foo: "", extra: "" },
+  });
+  // @ts-expect-error Not assignable
+  expectAssignable<RequestType<Data>>({ data: { noFoo: "" } });
+}
+
+function ignoredTestRequestTypesWithPathParameters() {
+  expectAssignable<RequestType<Data, Path>>({
+    data: { foo: "" },
+    pathParameters: { bar: "" },
+  });
+  expectAssignable<RequestType<null, Path>>({
+    pathParameters: { bar: "" },
+  });
+  // @ts-expect-error Not assignable
+  expectAssignable<RequestType<null, Path>>({});
+  expectAssignable<RequestType<null, Path>>({
+    // @ts-expect-error Not assignable
+    pathParameters: {},
+  });
+  expectAssignable<RequestType<null, Path>>({
+    // @ts-expect-error Not assignable
+    pathParameters: { foo: "", extra: "" },
+  });
+}
+
+function ignoredTestRequestTypesWithHeader() {
+  expectAssignable<RequestType<Data, Path, Header>>({
+    data: {
+      foo: "",
+    },
+    pathParameters: { bar: "" },
+    headers: { baz: "" },
+  });
+  expectAssignable<RequestType<null, Path, Header>>({
+    pathParameters: { bar: "" },
+    headers: { baz: "" },
+  });
+  expectAssignable<RequestType<null, null, Header>>({
+    headers: { baz: "" },
+  });
+
+  // @ts-expect-error Not assignable
+  expectAssignable<RequestType<null, null, Header>>({});
+  expectAssignable<RequestType<null, null, Header>>({
+    headers: {
+      // @ts-expect-error Not assignable
+      baz: 42,
+    },
+  });
+
+  expectAssignable<RequestType<null, null, Header>>({
+    // @ts-expect-error Not assignable
+    headers: {},
+  });
+  expectAssignable<RequestType<null, null, Header>>({
+    // @ts-expect-error Not assignable
+    data: {},
+    headers: {
+      baz: "",
+    },
+  });
+  expectAssignable<RequestType<null, null, Header>>({
+    // @ts-expect-error Not assignable
+    pathParameters: {},
+    headers: {
+      baz: "",
+    },
+  });
+}
+
+function ignoredTestAdditionalHeadersCanAlwaysBeSet() {
+  expectAssignable<RequestType<null>>({
+    headers: { extra: true },
+  });
+  expectAssignable<RequestType<null, null>>({
+    headers: { extra: true },
+  });
+  expectAssignable<RequestType<null, null, null>>({
+    headers: { extra: true },
+  });
+  expectAssignable<RequestType<Data>>({
+    data: {
+      foo: "",
+    },
+    headers: { extra: true },
+  });
+  expectAssignable<RequestType<null, Path>>({
+    pathParameters: {
+      bar: "",
+    },
+    headers: { extra: true },
+  });
+  expectAssignable<RequestType<null, null, Header>>({
+    headers: { extra: true, baz: "" },
+  });
+}
diff --git a/packages/commons/src/types/RequestFunction.test-types.ts b/packages/commons/src/types/RequestFunction.test-types.ts
@@ -0,0 +1,12 @@
+import { OpenAPIOperation, RequestFunction } from "../types/index.js";
+
+function ignoredTestEmptyRequestTypes() {
+  const f = {} as RequestFunction<OpenAPIOperation>;
+  void f();
+  void f({
+    headers: {},
+  });
+  void f({
+    headers: { extra: true },
+  });
+}
diff --git a/packages/commons/test-d/Response.ts → .../commons/src/types/Response.test-types.ts b/packages/commons/test-d/Response.ts → .../commons/src/types/Response.test-types.ts
@@ -1,11 +1,6 @@
-import { Response } from "../dist/esm/types/Response";
-import {
-  expectAssignable,
-  expectError,
-  expectNotAssignable,
-  expectType,
-} from "tsd";
+import { expectAssignable, expectNotAssignable, expectType } from "tsd";
 import { InternalAxiosRequestConfig } from "axios";
+import { Response } from "./Response.js";
 
 type Response200 = Response<{ a: string }, 200, "application/json">;
 type Response200Text = Response<{ text: string }, 200, "text/plain">;
@@ -60,22 +55,30 @@ expectNotAssignable<Response400>({
   ...additionalAxiosResponseData,
 });
 
-type SomeResponse = Response200 | Response200Text | Response201 | Response400;
-declare const someResponse: SomeResponse;
+function ignoredTestRequestTypesWithDataPathParameters() {
+  type SomeResponse = Response200 | Response200Text | Response201 | Response400;
+  const someResponse = {} as SomeResponse;
 
-expectType<200 | 201 | 400>(someResponse.status);
+  expectType<200 | 201 | 400>(someResponse.status);
 
-if (someResponse.status === 200) {
-  expectError(someResponse.data.a);
-  expectError(someResponse.data.b);
-  if (someResponse.mediaType === "text/plain") {
-    expectError(someResponse.data.a);
-    expectType<string>(someResponse.data.text);
-  } else {
-    expectError(someResponse.data.text);
-    expectType<string>(someResponse.data.a);
+  if (someResponse.status === 200) {
+    // @ts-expect-error > a is not in data
+    someResponse.data.a;
+    // @ts-expect-error > b is not in data
+    someResponse.data.b;
+
+    if (someResponse.mediaType === "text/plain") {
+      // @ts-expect-error > a is not in data
+      someResponse.data.a;
+      expectType<string>(someResponse.data.text);
+    } else {
+      // @ts-expect-error > text is not in data
+      someResponse.data.text;
+      expectType<string>(someResponse.data.a);
+    }
+  } else if (someResponse.status === 201) {
+    expectType<string>(someResponse.data.b);
+    // @ts-expect-error > a is not in data
+    someResponse.data.a;
   }
-} else if (someResponse.status === 201) {
-  expectType<string>(someResponse.data.b);
-  expectError(someResponse.data.a);
 }
diff --git a/packages/commons/test-d/assertStatus.ts → ...mons/src/types/assertStatus.test-types.ts b/packages/commons/test-d/assertStatus.ts → ...mons/src/types/assertStatus.test-types.ts
@@ -1,15 +1,16 @@
 import { expectAssignable, expectNotAssignable } from "tsd";
-import { Response } from "../dist/esm/types/Response.js";
-import assertStatus from "../dist/esm/types/assertStatus.js";
+import { Response } from "./Response.js";
+import assertStatus from "./assertStatus.js";
 
 type Response200 = Response<{ a: string }, 200, "application/json">;
 type Response201 = Response<{ b: string }, 201>;
 
 type SomeResponse = Response200 | Response201;
 declare const someResponse: SomeResponse;
 
-export function testAssertStatusAssertsAlsoTheCorrectResponseType() {
+function ignoredTestAssertStatusAssertsAlsoTheCorrectResponseType() {
   assertStatus(someResponse, 200);
   expectAssignable<Response200>(someResponse);
-  expectNotAssignable<Response201>(someResponse);
+  // @ts-expect-error Not assignable
+  expectAssignable<Response201>(someResponse);
 }
diff --git a/packages/commons/test-d/Request.ts b/packages/commons/test-d/Request.ts