test: added 10 unit tests for config and basic functionality

Author: constewart9

package.json

@@ -38,7 +38,7 @@
         "preversion": "npm run test",
         "version": "npm run compile && git add -A .",
         "watch": "tsc --build --watch",
-        "gen-comp": "cd ./types/codegen/ && npm run generate && cd ./generated && npm run build && cd ../../../ && npm run compile"
+        "gen-comp": "cd ./types/codegen/ && npm run generate && cd ./generated/typescript && npm run build && cd ../../../ && npm run compile"
     },
     "devDependencies": {
         "@commitlint/cli": "^19.8.1",

types/.gitignore

@@ -1,3 +1,6 @@
 LICENSE
 NOTICE
-SECURITY.md
+SECURITY.md
+codegen/scripts/**/*
+codegen/generated/**/*
+codegen/tests/fixtures/**/*

types/codegen/README.md

@@ -196,10 +196,45 @@ The validation script provides detailed reporting:
 - **Missing models**: Models that should be generated but aren't
 - **Extra models**: Intermediate models created by OpenAPI generator
 
+## Testing
+
+The `tests/` directory contains comprehensive tests for the OpenAPI code generation pipeline. These tests validate that your `openapitools.json` configuration and custom templates work correctly.
+
+### Running Tests
+
+```bash
+# Run all tests
+npm run test:unit
+
+# Inspect generated files for debugging
+KEEP_TEST_OUTPUT=1 npm run test:unit
+
+# Run specific test suites
+npm run test:unit -- --testPathPattern="field-addition"
+npm run test:unit -- --testPathPattern="openapi-normalizer"
+```
+
+### Test Coverage
+
+- **Field Addition Tests (8 tests)**: Validates TypeScript interfaces and Java records for optional/required fields
+- **Configuration Tests**: Ensures camelCase naming, ES6 exports, Java 21 compatibility, and custom templates  
+- **OpenAPI Normalizer Tests (2 tests)**: Tests inheritance vs property flattening based on configuration
+
+The tests use your actual `openapitools.json` configuration (not mocked) to ensure production validation and regression protection.
+
+**Key Features:**
+- Real configuration testing using your actual `openapitools.json`
+- Custom template validation (Java records vs classes)
+- Language-specific behavior testing (TypeScript inheritance, Java flattening)
+- Configuration-aware tests that adapt to your settings
+
+See [tests/README.md](tests/README.md) for detailed test documentation.
+
 ## Development Workflow
 
 1. **Add/modify schemas** in `schema/chatTypes.json`
 2. **Run generation**: `npm run generate`
 3. **Review validation**: Check for missing or extra models
 4. **Test integration**: Use generated types in your application
-5. **Commit changes**: Only commit schema files, not generated files
+5. **Run tests**: `npm run test:unit` to validate configuration and templates
+6. **Commit changes**: Only commit schema files, not generated files

types/codegen/package.json

@@ -9,11 +9,15 @@
         "generate:no-post": "npm run generate-schema && openapi-generator-cli generate",
         "test": "node scripts/post-test.js",
         "test:verbose": "node scripts/post-test.js --verbose",
+        "test:unit": "ts-mocha -b 'tests/unit/**/*.test.js' --bail false",
+        "test:all": "npm run test && npm run test:unit",
         "validate": "npm run test"
     },
     "devDependencies": {
         "@openapitools/openapi-generator-cli": "^2.21.4",
+        "@types/mocha": "^10.0.9",
         "@types/node": "^24.0.4",
+        "ts-mocha": "^11.1.0",
         "ts-node": "^10.9.2",
         "typescript": "^5.8.3"
     }

types/codegen/tests/README.md

@@ -0,0 +1,104 @@
+# OpenAPI Code Generation Tests
+
+Comprehensive test suite validating OpenAPI code generation pipeline using your actual `openapitools.json` configuration and custom templates.
+
+## Test Structure
+
+```
+tests/
+├── utils/test-helpers.js              # Shared utilities
+└── unit/
+    ├── field-addition.test.js         # Field scenarios & configuration validation
+    └── openapi-normalizer.test.js     # OpenAPI normalizer features
+```
+
+## Running Tests
+
+```bash
+# Normal test run
+npm run test:unit
+
+# Inspect generated files
+KEEP_TEST_OUTPUT=1 npm run test:unit
+
+# Run specific tests
+npm run test:unit -- --testPathPattern="field-addition"
+```
+
+## Test Coverage
+
+### Field Addition Tests (8 tests)
+Validates field addition scenarios and configuration compliance:
+
+- **Field Testing**: Base schema, optional fields (`field?: string`), required fields (`field: string`)
+- **Configuration Validation**: 
+  - TypeScript camelCase naming (`displayName` vs `display_name`)
+  - ES6 exports (`export interface` vs `module.exports`)
+  - Java 21 compatibility (no deprecated features)
+  - Model filtering (`global-property models=TestModel`)
+  - Custom templates (Java records vs classes)
+
+### OpenAPI Normalizer Tests (2 tests)
+Validates OpenAPI normalizer features with language-specific behavior:
+
+- **REF_AS_PARENT_IN_ALLOF**: Configuration-aware testing
+  - TypeScript: Tests inheritance (`extends BaseModel`) vs flattening
+  - Java: Always flattens properties (records don't support inheritance)
+- **Custom Template Compatibility**: Ensures normalizer works with custom templates
+
+## Key Features
+
+### Real Configuration Testing
+- Uses your actual `openapitools.json` (not mocked)
+- Tests adapt behavior based on your configuration
+- Validates custom templates are actually used
+
+### Language-Specific Validation
+- TypeScript: Interfaces, optional fields, ES6 exports, inheritance
+- Java: Records, annotations (`@Nonnull`, `@Nullable`), property flattening
+
+### Robust Design
+- Shared utilities prevent code duplication
+- Configuration-aware tests adapt to changes
+- Clean test isolation with conditional cleanup
+- Clear failure points with specific test names
+
+## Generated Validation Examples
+
+**TypeScript**:
+```typescript
+export interface TestModel {
+    id: string;
+    displayName: string;        // camelCase naming
+    optionalField?: string;     // Optional field syntax
+}
+```
+
+**Java**:
+```java
+public record TestModel(        // Custom template (record vs class)
+    @JsonProperty("id") @Nonnull String id,
+    @JsonProperty("displayName") @Nonnull String displayName
+) {}
+```
+
+## Adding New Tests
+
+**Extend existing files** for simple checks fitting current themes.
+
+**Create new files** for complex features deserving dedicated test suites:
+
+```javascript
+const { generateCodeWithConfig, createTestDirectory } = require('../utils/test-helpers')
+
+describe('New Feature Tests', () => {
+    // Use shared utilities for consistency
+})
+```
+
+## Benefits
+
+- **Production validation**: Tests your actual build pipeline
+- **Regression protection**: Catches configuration and template breaks  
+- **Maintainable**: Shared utilities, configuration-aware testing
+- **Developer-friendly**: Clear test names, easy debugging with `KEEP_TEST_OUTPUT`