Purely rely on e2e tests for exercising the generator

Signed-off-by: Juan Cruz Viotti <jv@jviotti.com>

Author: jviotti

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/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
+}

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

@@ -0,0 +1,80 @@
+import { TreeNode } from "./expected";
+
+
+// Valid: minimal node with just name
+const leaf: TreeNode = {
+  name: "leaf"
+};
+
+// Valid: node with children
+const parent: TreeNode = {
+  name: "parent",
+  children: [
+    { name: "child1" },
+    { name: "child2" }
+  ]
+};
+
+// Valid: deeply nested structure
+const root: TreeNode = {
+  name: "root",
+  children: [
+    {
+      name: "branch1",
+      children: [
+        { name: "leaf1" },
+        { name: "leaf2" }
+      ]
+    },
+    {
+      name: "branch2",
+      children: []
+    }
+  ]
+};
+
+// Valid: node with parent reference
+const childWithParent: TreeNode = {
+  name: "child",
+  parent: { name: "myParent" }
+};
+
+// Valid: complex tree with parent references
+const complexTree: TreeNode = {
+  name: "root",
+  children: [
+    {
+      name: "child",
+      parent: { name: "root" },
+      children: [
+        { name: "grandchild" }
+      ]
+    }
+  ]
+};
+
+// Invalid: missing required name
+// @ts-expect-error - name is required
+const missingName: TreeNode = {
+  children: []
+};
+
+// Invalid: wrong type for name
+const wrongNameType: TreeNode = {
+  // @ts-expect-error - name must be string
+  name: 123
+};
+
+// Invalid: children must be array of TreeNode
+const wrongChildrenType: TreeNode = {
+  name: "node",
+  // @ts-expect-error - children must be array of TreeNode
+  children: "not an array"
+};
+
+// Invalid: extra property (additionalProperties: false)
+const extraProperty: TreeNode = {
+  name: "node",
+  // @ts-expect-error - extra property not allowed
+  extra: "not allowed"
+};

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

@@ -0,0 +1,28 @@
+export type SchemaSayhello = string;
+
+export type SchemaPathtofile = string;
+
+export type SchemaMypropertyname = string;
+
+export type SchemaLine1line2 = string;
+
+export type SchemaCol1col2 = string;
+
+export type SchemaClass = string;
+
+export type Schema_123abc = string;
+
+export type Schema$specialchars = string;
+
+export type SchemaAdditionalProperties = never;
+
+export interface Schema {
+  "say \"hello\""?: SchemaSayhello;
+  "path\\to\\file"?: SchemaPathtofile;
+  "line1\nline2"?: SchemaLine1line2;
+  "col1\tcol2"?: SchemaCol1col2;
+  "$special@chars"?: Schema$specialchars;
+  "my property name"?: SchemaMypropertyname;
+  "123abc"?: Schema_123abc;
+  "class"?: SchemaClass;
+}