ut increase

Signed-off-by: xil <fridalu66@gmail.com>

Author: lucy66hw

tools/proto-convert/test/SchemaModifier.test.ts

@@ -648,7 +648,7 @@ describe('SchemaModifier', () => {
             expect(schema.$ref).toBe('#/components/schemas/SortOrderSingleMap');
             expect(schema.type).toBeUndefined();
             expect(schema.properties).toBeUndefined();
-            
+
             // New SortOrderSingleMap schema should be created
             expect(doc.components!.schemas!.SortOrderSingleMap).toBeDefined();
             const mapSchema = doc.components!.schemas!.SortOrderSingleMap as OpenAPIV3.SchemaObject;
@@ -737,6 +737,71 @@ describe('SchemaModifier', () => {
 
             expect(schema.additionalProperties).toBeDefined();
         });
+
+        it('should use inline modification for QueryContainer properties', () => {
+            const doc = createDocument();
+            doc.components!.schemas!.BoolQuery = {
+                type: 'object',
+                properties: {
+                    must: { 
+                        type: 'array',
+                        items: { type: 'string' }
+                    }
+                }
+            };
+
+            const modifier = new SchemaModifier(doc);
+            const visit = new Set();
+
+            const schema: any = {
+                type: 'object',
+                additionalProperties: {
+                    $ref: '#/components/schemas/BoolQuery'
+                },
+                minProperties: 1,
+                maxProperties: 1
+            };
+
+            // Pass 'QueryContainer' as parent schema name
+            modifier.simplifySingleMapSchema(schema, visit, 'QueryContainer');
+
+            // Should use old inline behavior - becomes a $ref directly (no SingleMap wrapper)
+            expect(schema.$ref).toBe('#/components/schemas/BoolQuery');
+            expect(doc.components!.schemas!.BoolQuerySingleMap).toBeUndefined();
+            
+            // Properties should be deleted
+            expect(schema.type).toBeUndefined();
+            expect(schema.additionalProperties).toBeUndefined();
+            expect(schema.minProperties).toBeUndefined();
+            expect(schema.maxProperties).toBeUndefined();
+        });
+
+        it('should create SingleMap for non-QueryContainer properties', () => {
+            const doc = createDocument();
+            doc.components!.schemas!.SortOrder = {
+                type: 'string',
+                enum: ['asc', 'desc']
+            };
+
+            const modifier = new SchemaModifier(doc);
+            const visit = new Set();
+
+            const schema: any = {
+                type: 'object',
+                additionalProperties: {
+                    $ref: '#/components/schemas/SortOrder'
+                },
+                minProperties: 1,
+                maxProperties: 1
+            };
+
+            // Pass a different parent schema name (not QueryContainer)
+            modifier.simplifySingleMapSchema(schema, visit, 'AggregateOrder');
+
+            // Should use new SingleMap behavior
+            expect(schema.$ref).toBe('#/components/schemas/SortOrderSingleMap');
+            expect(doc.components!.schemas!.SortOrderSingleMap).toBeDefined();
+        });
     });
 
     describe('convertAdditionalPropertiesToProperty - edge cases', () => {
@@ -894,5 +959,208 @@ describe('SchemaModifier', () => {
             expect(result).toHaveProperty('properties');
             expect((result as any).properties).toHaveProperty('customValue');
         });
+
+        it('should handle oneOf schemas recursively', () => {
+            const doc = createDocument();
+            doc.components!.schemas!.OptionA = {
+                type: 'object',
+                properties: { a: { type: 'string' } }
+            };
+            doc.components!.schemas!.OptionB = {
+                type: 'object',
+                properties: { b: { type: 'number' } }
+            };
+            doc.components!.schemas!.UnionType = {
+                oneOf: [
+                    { $ref: '#/components/schemas/OptionA' },
+                    { $ref: '#/components/schemas/OptionB' }
+                ]
+            };
+
+            const modifier = new SchemaModifier(doc);
+            const visit = new Set();
+
+            const schema = { $ref: '#/components/schemas/UnionType' };
+            modifier.reconstructAdditionalPropertySchema(schema, visit);
+
+            const optionA = doc.components!.schemas!.OptionA as any;
+            const optionB = doc.components!.schemas!.OptionB as any;
+            
+            // Both options should have the field property added
+            expect(optionA.properties).toHaveProperty('field');
+            expect(optionB.properties).toHaveProperty('field');
+        });
+
+        it('should handle anyOf schemas recursively', () => {
+            const doc = createDocument();
+            doc.components!.schemas!.OptionC = {
+                type: 'object',
+                properties: { c: { type: 'string' } }
+            };
+            doc.components!.schemas!.OptionD = {
+                type: 'object',
+                properties: { d: { type: 'number' } }
+            };
+            doc.components!.schemas!.FlexibleType = {
+                anyOf: [
+                    { $ref: '#/components/schemas/OptionC' },
+                    { $ref: '#/components/schemas/OptionD' }
+                ]
+            };
+
+            const modifier = new SchemaModifier(doc);
+            const visit = new Set();
+
+            const schema = { $ref: '#/components/schemas/FlexibleType' };
+            modifier.reconstructAdditionalPropertySchema(schema, visit);
+
+            const optionC = doc.components!.schemas!.OptionC as any;
+            const optionD = doc.components!.schemas!.OptionD as any;
+            
+            // Both options should have the field property added
+            expect(optionC.properties).toHaveProperty('field');
+            expect(optionD.properties).toHaveProperty('field');
+        });
+
+        it('should return original schema if already visited', () => {
+            const doc = createDocument();
+            doc.components!.schemas!.TestSchema = {
+                type: 'object',
+                properties: { test: { type: 'string' } }
+            };
+
+            const modifier = new SchemaModifier(doc);
+            const visit = new Set();
+            
+            const schema = { $ref: '#/components/schemas/TestSchema' };
+            const resolvedSchema = doc.components!.schemas!.TestSchema;
+            
+            visit.add(resolvedSchema);
+            
+            const result = modifier.reconstructAdditionalPropertySchema(schema, visit);
+            
+            // Should return original schema without modification
+            expect(result).toBe(schema);
+            expect((resolvedSchema as any).properties).not.toHaveProperty('field');
+        });
+
+        it('should handle primitive types without title', () => {
+            const doc = createDocument();
+            const modifier = new SchemaModifier(doc);
+            const visit = new Set();
+
+            const schema: any = { type: 'number' };
+            const result = modifier.reconstructAdditionalPropertySchema(schema, visit);
+
+            expect(result).toHaveProperty('properties');
+            expect((result as any).properties).toHaveProperty('value');
+        });
+
+        it('should log error when field property already exists', () => {
+            const doc = createDocument();
+            doc.components!.schemas!.ConflictSchema = {
+                type: 'object',
+                properties: {
+                    field: { type: 'string' },
+                    existing: { type: 'number' }
+                }
+            };
+
+            const modifier = new SchemaModifier(doc);
+            const visit = new Set();
+
+            const schema = { $ref: '#/components/schemas/ConflictSchema' };
+            
+            const errorSpy = jest.spyOn(console, 'error').mockImplementation();
+            
+            modifier.reconstructAdditionalPropertySchema(schema, visit);
+            
+            expect(errorSpy).toHaveBeenCalled();
+            errorSpy.mockRestore();
+        });
+    });
+
+    describe('getTypeName', () => {
+        it('should extract name from $ref', () => {
+            const doc = createDocument();
+            const modifier = new SchemaModifier(doc) as any;
+
+            const schema = { $ref: '#/components/schemas/TestType' };
+            const result = modifier.getTypeName(schema);
+
+            expect(result).toBe('TestType');
+        });
+
+        it('should extract name from title', () => {
+            const doc = createDocument();
+            const modifier = new SchemaModifier(doc) as any;
+
+            const schema: OpenAPIV3.SchemaObject = { type: 'object', title: 'CustomTitle' };
+            const result = modifier.getTypeName(schema);
+
+            expect(result).toBe('CustomTitle');
+        });
+
+        it('should return null if no $ref or title', () => {
+            const doc = createDocument();
+            const modifier = new SchemaModifier(doc) as any;
+
+            const schema: OpenAPIV3.SchemaObject = { type: 'string' };
+            const result = modifier.getTypeName(schema);
+
+            expect(result).toBeNull();
+        });
+    });
+
+    describe('createAdditionalPropertySchema', () => {
+        it('should create schema with field property', () => {
+            const doc = createDocument();
+            const modifier = new SchemaModifier(doc) as any;
+
+            const result = modifier.createAdditionalPropertySchema();
+
+            expect(result.type).toBe('object');
+            expect(result.properties).toHaveProperty('field');
+            expect(result.properties!.field).toEqual({ type: 'string' });
+        });
+    });
+
+    describe('isArraySchemaObject', () => {
+        it('should return true for array schema with items', () => {
+            const doc = createDocument();
+            const modifier = new SchemaModifier(doc) as any;
+
+            const schema: OpenAPIV3.ArraySchemaObject = {
+                type: 'array',
+                items: { type: 'string' }
+            };
+
+            const result = modifier.isArraySchemaObject(schema);
+            expect(result).toBe(true);
+        });
+
+        it('should return false for non-array schema', () => {
+            const doc = createDocument();
+            const modifier = new SchemaModifier(doc) as any;
+
+            const schema: OpenAPIV3.SchemaObject = {
+                type: 'object'
+            };
+
+            const result = modifier.isArraySchemaObject(schema);
+            expect(result).toBe(false);
+        });
+
+        it('should return false for array without items', () => {
+            const doc = createDocument();
+            const modifier = new SchemaModifier(doc) as any;
+
+            const schema: any = {
+                type: 'array'
+            };
+
+            const result = modifier.isArraySchemaObject(schema);
+            expect(result).toBe(false);
+        });
     });
 });