Purely rely on e2e tests for exercising the generator

CMakeLists.txt

@@ -77,7 +77,6 @@ if(CODEGEN_TESTS)
   endif()
 
   if(CODEGEN_GENERATOR)
-    add_subdirectory(test/generator)
     add_subdirectory(test/e2e/typescript)
   endif()
 

test/e2e/typescript/2020-12/bundled_schema/expected.d.ts

@@ -0,0 +1,37 @@
+export type ApiResponseMeta = ApiResponseHttpsexamplecomschemasmetadata;
+
+export type ApiResponseData = ApiResponseHttpsexamplecomschemasuser;
+
+export type ApiResponseAdditionalProperties = never;
+
+export type ApiResponseHttpsexamplecomschemasuserName = string;
+
+export type ApiResponseHttpsexamplecomschemasuserId = number;
+
+export type ApiResponseHttpsexamplecomschemasuserEmail = ApiResponseHttpsexamplecomschemasemail;
+
+export type ApiResponseHttpsexamplecomschemasuserAdditionalProperties = never;
+
+export interface ApiResponseHttpsexamplecomschemasuser {
+  "id": ApiResponseHttpsexamplecomschemasuserId;
+  "name": ApiResponseHttpsexamplecomschemasuserName;
+  "email"?: ApiResponseHttpsexamplecomschemasuserEmail;
+}
+
+export type ApiResponseHttpsexamplecomschemasmetadataVersion = number;
+
+export type ApiResponseHttpsexamplecomschemasmetadataTimestamp = string;
+
+export type ApiResponseHttpsexamplecomschemasmetadataAdditionalProperties = never;
+
+export interface ApiResponseHttpsexamplecomschemasmetadata {
+  "timestamp"?: ApiResponseHttpsexamplecomschemasmetadataTimestamp;
+  "version"?: ApiResponseHttpsexamplecomschemasmetadataVersion;
+}
+
+export type ApiResponseHttpsexamplecomschemasemail = string;
+
+export interface ApiResponse {
+  "data": ApiResponseData;
+  "meta": ApiResponseMeta;
+}

test/e2e/typescript/2020-12/bundled_schema/options.json

@@ -0,0 +1,3 @@
+{
+  "defaultPrefix": "ApiResponse"
+}

test/e2e/typescript/2020-12/bundled_schema/schema.json

@@ -0,0 +1,42 @@
+{
+  "$id": "https://example.com/api/response",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "description": "A bundled API response schema with embedded resource schemas",
+  "type": "object",
+  "required": [ "data", "meta" ],
+  "properties": {
+    "data": { "$ref": "https://example.com/schemas/user" },
+    "meta": { "$ref": "https://example.com/schemas/metadata" }
+  },
+  "additionalProperties": false,
+  "$defs": {
+    "https://example.com/schemas/user": {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "$id": "https://example.com/schemas/user",
+      "type": "object",
+      "required": [ "id", "name" ],
+      "properties": {
+        "id": { "type": "integer" },
+        "name": { "type": "string" },
+        "email": { "$ref": "https://example.com/schemas/email" }
+      },
+      "additionalProperties": false
+    },
+    "https://example.com/schemas/email": {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "$id": "https://example.com/schemas/email",
+      "type": "string",
+      "format": "email"
+    },
+    "https://example.com/schemas/metadata": {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "$id": "https://example.com/schemas/metadata",
+      "type": "object",
+      "properties": {
+        "timestamp": { "type": "string" },
+        "version": { "type": "integer" }
+      },
+      "additionalProperties": false
+    }
+  }
+}

test/e2e/typescript/2020-12/bundled_schema/test.ts

@@ -0,0 +1,102 @@
+import {
+  ApiResponse,
+  ApiResponseHttpsexamplecomschemasuser,
+  ApiResponseHttpsexamplecomschemasmetadata,
+  ApiResponseHttpsexamplecomschemasemail
+} from "./expected";
+
+
+// Valid: full API response with all fields
+const fullResponse: ApiResponse = {
+  data: {
+    id: 123,
+    name: "John Doe",
+    email: "[email protected]"
+  },
+  meta: {
+    timestamp: "2024-01-15T10:30:00Z",
+    version: 1
+  }
+};
+
+// Valid: minimal response (required fields only)
+const minimalResponse: ApiResponse = {
+  data: {
+    id: 1,
+    name: "Jane"
+  },
+  meta: {}
+};
+
+// Valid: user object directly
+const user: ApiResponseHttpsexamplecomschemasuser = {
+  id: 42,
+  name: "Test User"
+};
+
+// Valid: user with email
+const userWithEmail: ApiResponseHttpsexamplecomschemasuser = {
+  id: 42,
+  name: "Test User",
+  email: "[email protected]"
+};
+
+// Valid: metadata object
+const metadata: ApiResponseHttpsexamplecomschemasmetadata = {
+  timestamp: "2024-01-15",
+  version: 2
+};
+
+// Valid: email is just a string
+const email: ApiResponseHttpsexamplecomschemasemail = "[email protected]";
+
+// Invalid: missing required field 'data'
+// @ts-expect-error - data is required
+const missingData: ApiResponse = {
+  meta: {}
+};
+
+// Invalid: missing required field 'meta'
+// @ts-expect-error - meta is required
+const missingMeta: ApiResponse = {
+  data: { id: 1, name: "Test" }
+};
+
+// Invalid: user missing required 'id'
+const userMissingId: ApiResponse = {
+  // @ts-expect-error - id is required on user
+  data: {
+    name: "Test"
+  },
+  meta: {}
+};
+
+// Invalid: user missing required 'name'
+const userMissingName: ApiResponse = {
+  // @ts-expect-error - name is required on user
+  data: {
+    id: 1
+  },
+  meta: {}
+};
+
+// Invalid: wrong type for user id
+const wrongIdType: ApiResponse = {
+  data: {
+    // @ts-expect-error - id must be number
+    id: "not-a-number",
+    name: "Test"
+  },
+  meta: {}
+};
+
+// Invalid: extra property on user (additionalProperties: false)
+const extraUserProp: ApiResponse = {
+  data: {
+    id: 1,
+    name: "Test",
+    // @ts-expect-error - extra property not allowed
+    extra: "not allowed"
+  },
+  meta: {}
+};

test/e2e/typescript/2020-12/enum_with_complex_values/expected.d.ts

@@ -0,0 +1,19 @@
+export type SchemaSimpleEnum = "foo" | "bar" | "baz";
+
+export type SchemaMixedEnum = "active" | 42 | true | null;
+
+export type SchemaEnumWithObject = "simple" | {
+  "type": "complex",
+  "value": 123
+};
+
+export type SchemaEnumWithArray = 1 | [ 1, 2, 3 ];
+
+export type SchemaAdditionalProperties = never;
+
+export interface Schema {
+  "simpleEnum"?: SchemaSimpleEnum;
+  "mixedEnum"?: SchemaMixedEnum;
+  "enumWithObject"?: SchemaEnumWithObject;
+  "enumWithArray"?: SchemaEnumWithArray;
+}

test/e2e/typescript/2020-12/enum_with_complex_values/options.json

@@ -0,0 +1,3 @@
+{
+  "defaultPrefix": "Schema"
+}

test/e2e/typescript/2020-12/enum_with_complex_values/schema.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "simpleEnum": {
+      "enum": [ "foo", "bar", "baz" ]
+    },
+    "mixedEnum": {
+      "enum": [ "active", 42, true, null ]
+    },
+    "enumWithObject": {
+      "enum": [ "simple", { "type": "complex", "value": 123 } ]
+    },
+    "enumWithArray": {
+      "enum": [ 1, [ 1, 2, 3 ] ]
+    }
+  },
+  "additionalProperties": false
+}

test/e2e/typescript/2020-12/enum_with_complex_values/test.ts

@@ -0,0 +1,59 @@
+import {
+  Schema,
+  SchemaSimpleEnum,
+  SchemaMixedEnum,
+  SchemaEnumWithObject,
+  SchemaEnumWithArray
+} from "./expected";
+
+
+// Valid: simple string enum values
+const simple1: SchemaSimpleEnum = "foo";
+const simple2: SchemaSimpleEnum = "bar";
+const simple3: SchemaSimpleEnum = "baz";
+
+// Invalid: wrong string for simple enum
+// @ts-expect-error - must be "foo" | "bar" | "baz"
+const simpleInvalid: SchemaSimpleEnum = "invalid";
+
+// Valid: mixed enum values
+const mixed1: SchemaMixedEnum = "active";
+const mixed2: SchemaMixedEnum = 42;
+const mixed3: SchemaMixedEnum = true;
+const mixed4: SchemaMixedEnum = null;
+
+// Invalid: wrong value for mixed enum
+// @ts-expect-error - must be "active" | 42 | true | null
+const mixedInvalid: SchemaMixedEnum = "inactive";
+
+// Valid: enum with object value
+const withObj1: SchemaEnumWithObject = "simple";
+const withObj2: SchemaEnumWithObject = { type: "complex", value: 123 };
+
+// Invalid: completely wrong type for enum with object
+// @ts-expect-error - must be "simple" or the exact object literal
+const withObjInvalid: SchemaEnumWithObject = "wrong";
+
+// Valid: enum with array value
+const withArr1: SchemaEnumWithArray = 1;
+const withArr2: SchemaEnumWithArray = [ 1, 2, 3 ];
+
+// Invalid: wrong array
+// @ts-expect-error - must be exactly [1, 2, 3]
+const withArrInvalid: SchemaEnumWithArray = [ 1, 2 ];
+
+// Valid: full schema object
+const fullSchema: Schema = {
+  simpleEnum: "foo",
+  mixedEnum: 42,
+  enumWithObject: { type: "complex", value: 123 },
+  enumWithArray: [ 1, 2, 3 ]
+};
+
+// Valid: partial schema
+const partialSchema: Schema = {
+  simpleEnum: "bar"
+};
+
+// Valid: empty schema (all optional)
+const emptySchema: Schema = {};

test/e2e/typescript/2020-12/recursive_schema/expected.d.ts

@@ -0,0 +1,15 @@
+export type TreeNodeParent = TreeNode;
+
+export type TreeNodeName = string;
+
+export type TreeNodeChildrenItems = TreeNode;
+
+export type TreeNodeChildren = TreeNodeChildrenItems[];
+
+export type TreeNodeAdditionalProperties = never;
+
+export interface TreeNode {
+  "name": TreeNodeName;
+  "children"?: TreeNodeChildren;
+  "parent"?: TreeNodeParent;
+}

test/e2e/typescript/2020-12/recursive_schema/options.json

@@ -0,0 +1,3 @@
+{
+  "defaultPrefix": "TreeNode"
+}

test/e2e/typescript/2020-12/recursive_schema/schema.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "required": [ "name" ],
+  "properties": {
+    "name": { "type": "string" },
+    "children": {
+      "type": "array",
+      "items": { "$ref": "#" }
+    },
+    "parent": { "$ref": "#" }
+  },
+  "additionalProperties": false
+}