src/test/java/com/github/jsonschemafaker/generators/IndividualGeneratorsTest.java - main - gns34/json-schema-faker-java

src/test/java/com/github/jsonschemafaker/generators/IndividualGeneratorsTest.java
538 строк20 KB
ankit-d-sharma
Added json-schema-faker-java
01 авг 2025, 22:51
01 авг 2025, 22:518ff4abd
package com.github.jsonschemafaker.generators;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.github.jsonschemafaker.FakerConfig;
import com.github.jsonschemafaker.options.Options;
import com.github.javafaker.Faker;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import java.util.Locale;

import static org.junit.jupiter.api.Assertions.*;

/**
 * Comprehensive tests for individual generators.
 */
public class IndividualGeneratorsTest {
    
    private ObjectMapper objectMapper;
    private FakerConfig config;
    private Options options;
    private Faker faker;
    private GeneratorFactory factory;
    
    @BeforeEach
    public void setUp() {
        objectMapper = new ObjectMapper();
        config = new FakerConfig();
        options = new Options();
        faker = new Faker(Locale.ENGLISH);
        factory = new GeneratorFactory(options);
    }
    
    // ==================== STRING GENERATOR TESTS ====================
    
    @Test
    public void testStringGeneratorWithMinMaxLength() throws Exception {
        String schema = "{\n" +
                "  \"type\": \"string\",\n" +
                "  \"minLength\": 10,\n" +
                "  \"maxLength\": 20\n" +
                "}";
        
        JsonNode schemaNode = objectMapper.readTree(schema);
        StringGenerator generator = new StringGenerator(config, schemaNode, options, faker);
        
        for (int i = 0; i < 100; i++) {
            JsonNode result = generator.generate();
            assertNotNull(result);
            assertTrue(result.isTextual());
            String value = result.asText();
            assertTrue(value.length() >= 10, "Value length: " + value.length());
            assertTrue(value.length() <= 20, "Value length: " + value.length());
        }
    }
    
    @Test
    public void testStringGeneratorWithFormat() throws Exception {
        String schema = "{\n" +
                "  \"type\": \"string\",\n" +
                "  \"format\": \"email\"\n" +
                "}";
        
        JsonNode schemaNode = objectMapper.readTree(schema);
        StringGenerator generator = new StringGenerator(config, schemaNode, options, faker);
        
        for (int i = 0; i < 50; i++) {
            JsonNode result = generator.generate();
            assertNotNull(result);
            assertTrue(result.isTextual());
            String value = result.asText();
            assertTrue(value.contains("@"), "Value: " + value);
        }
    }
    
    @Test
    public void testStringGeneratorWithEnum() throws Exception {
        String schema = "{\n" +
                "  \"type\": \"string\",\n" +
                "  \"enum\": [\"red\", \"green\", \"blue\"]\n" +
                "}";
        
        JsonNode schemaNode = objectMapper.readTree(schema);
        StringGenerator generator = new StringGenerator(config, schemaNode, options, faker);
        
        for (int i = 0; i < 50; i++) {
            JsonNode result = generator.generate();
            assertNotNull(result);
            assertTrue(result.isTextual());
            String value = result.asText();
            assertTrue(value.equals("red") || value.equals("green") || value.equals("blue"), 
                      "Value: " + value);
        }
    }
    
    @Test
    public void testStringGeneratorWithDefault() throws Exception {
        String schema = "{\n" +
                "  \"type\": \"string\",\n" +
                "  \"default\": \"default-value\"\n" +
                "}";
        
        JsonNode schemaNode = objectMapper.readTree(schema);
        StringGenerator generator = new StringGenerator(config, schemaNode, options, faker);
        
        JsonNode result = generator.generate();
        assertNotNull(result);
        assertTrue(result.isTextual());
        assertEquals("default-value", result.asText());
    }
    
    @Test
    public void testStringGeneratorWithPattern() throws Exception {
        String schema = "{\n" +
                "  \"type\": \"string\",\n" +
                "  \"pattern\": \"^[A-Za-z]+$\"\n" +
                "}";
        
        JsonNode schemaNode = objectMapper.readTree(schema);
        StringGenerator generator = new StringGenerator(config, schemaNode, options, faker);
        
        for (int i = 0; i < 20; i++) {
            JsonNode result = generator.generate();
            assertNotNull(result);
            assertTrue(result.isTextual());
            String value = result.asText();
            assertTrue(value.matches("^[A-Za-z]+$"), "Value: " + value);
        }
    }
    
    // ==================== NUMBER GENERATOR TESTS ====================
    
    @Test
    public void testNumberGeneratorWithMinMax() throws Exception {
        String schema = "{\n" +
                "  \"type\": \"number\",\n" +
                "  \"minimum\": 10.0,\n" +
                "  \"maximum\": 100.0\n" +
                "}";
        
        JsonNode schemaNode = objectMapper.readTree(schema);
        NumberGenerator generator = new NumberGenerator(config, schemaNode, options, faker);
        
        for (int i = 0; i < 100; i++) {
            JsonNode result = generator.generate();
            assertNotNull(result);
            assertTrue(result.isDouble());
            double value = result.asDouble();
            assertTrue(value >= 10.0, "Value: " + value);
            assertTrue(value <= 100.0, "Value: " + value);
        }
    }
    
    @Test
    public void testNumberGeneratorWithMultipleOf() throws Exception {
        String schema = "{\n" +
                "  \"type\": \"number\",\n" +
                "  \"minimum\": 0.0,\n" +
                "  \"maximum\": 10.0,\n" +
                "  \"multipleOf\": 0.5\n" +
                "}";
        
        JsonNode schemaNode = objectMapper.readTree(schema);
        NumberGenerator generator = new NumberGenerator(config, schemaNode, options, faker);
        
        for (int i = 0; i < 50; i++) {
            JsonNode result = generator.generate();
            assertNotNull(result);
            assertTrue(result.isDouble());
            double value = result.asDouble();
            assertTrue(value >= 0.0, "Value: " + value);
            assertTrue(value <= 10.0, "Value: " + value);
            assertEquals(0.0, value % 0.5, 0.001, "Value: " + value);
        }
    }
    
    // ==================== INTEGER GENERATOR TESTS ====================
    
    @Test
    public void testIntegerGeneratorWithMinMax() throws Exception {
        String schema = "{\n" +
                "  \"type\": \"integer\",\n" +
                "  \"minimum\": 1,\n" +
                "  \"maximum\": 100\n" +
                "}";
        
        JsonNode schemaNode = objectMapper.readTree(schema);
        NumberGenerator generator = new NumberGenerator(config, schemaNode, options, faker);
        
        for (int i = 0; i < 100; i++) {
            JsonNode result = generator.generate();
            assertNotNull(result);
            assertTrue(result.isInt());
            int value = result.asInt();
            assertTrue(value >= 1, "Value: " + value);
            assertTrue(value <= 100, "Value: " + value);
        }
    }
    
    @Test
    public void testIntegerGeneratorWithMultipleOf() throws Exception {
        String schema = "{\n" +
                "  \"type\": \"integer\",\n" +
                "  \"minimum\": 0,\n" +
                "  \"maximum\": 20,\n" +
                "  \"multipleOf\": 2\n" +
                "}";
        
        JsonNode schemaNode = objectMapper.readTree(schema);
        NumberGenerator generator = new NumberGenerator(config, schemaNode, options, faker);
        
        for (int i = 0; i < 50; i++) {
            JsonNode result = generator.generate();
            assertNotNull(result);
            assertTrue(result.isInt());
            int value = result.asInt();
            assertTrue(value >= 0, "Value: " + value);
            assertTrue(value <= 20, "Value: " + value);
            assertEquals(0, value % 2, "Value: " + value);
        }
    }
    
    // ==================== BOOLEAN GENERATOR TESTS ====================
    
    @Test
    public void testBooleanGenerator() throws Exception {
        String schema = "{\n" +
                "  \"type\": \"boolean\"\n" +
                "}";
        
        JsonNode schemaNode = objectMapper.readTree(schema);
        BooleanGenerator generator = new BooleanGenerator(config, schemaNode, options, faker);
        
        for (int i = 0; i < 50; i++) {
            JsonNode result = generator.generate();
            assertNotNull(result);
            assertTrue(result.isBoolean());
        }
    }
    
    @Test
    public void testBooleanGeneratorWithEnum() throws Exception {
        String schema = "{\n" +
                "  \"type\": \"boolean\",\n" +
                "  \"enum\": [true]\n" +
                "}";
        
        JsonNode schemaNode = objectMapper.readTree(schema);
        BooleanGenerator generator = new BooleanGenerator(config, schemaNode, options, faker);
        
        JsonNode result = generator.generate();
        assertNotNull(result);
        assertTrue(result.isBoolean());
        assertTrue(result.asBoolean(), "Value should be true");
    }
    
    // ==================== ARRAY GENERATOR TESTS ====================
    
    @Test
    public void testArrayGeneratorWithMinMaxItems() throws Exception {
        String schema = "{\n" +
                "  \"type\": \"array\",\n" +
                "  \"items\": {\n" +
                "    \"type\": \"string\"\n" +
                "  },\n" +
                "  \"minItems\": 2,\n" +
                "  \"maxItems\": 5\n" +
                "}";
        
        JsonNode schemaNode = objectMapper.readTree(schema);
        ArrayGenerator generator = new ArrayGenerator(config, schemaNode, factory, options, faker);
        
        for (int i = 0; i < 50; i++) {
            JsonNode result = generator.generate();
            assertNotNull(result);
            assertTrue(result.isArray());
            assertTrue(result.size() >= 2, "Array size: " + result.size());
            assertTrue(result.size() <= 5, "Array size: " + result.size());
            
            for (JsonNode item : result) {
                assertTrue(item.isTextual());
            }
        }
    }
    
    @Test
    public void testArrayGeneratorWithTupleValidation() throws Exception {
        String schema = "{\n" +
                "  \"type\": \"array\",\n" +
                "  \"items\": [\n" +
                "    {\n" +
                "      \"type\": \"string\",\n" +
                "      \"format\": \"name\"\n" +
                "    },\n" +
                "    {\n" +
                "      \"type\": \"integer\",\n" +
                "      \"minimum\": 18,\n" +
                "      \"maximum\": 100\n" +
                "    }\n" +
                "  ]\n" +
                "}";
        
        JsonNode schemaNode = objectMapper.readTree(schema);
        ArrayGenerator generator = new ArrayGenerator(config, schemaNode, factory, options, faker);
        
        for (int i = 0; i < 20; i++) {
            JsonNode result = generator.generate();
            assertNotNull(result);
            assertTrue(result.isArray());
            assertTrue(result.size() >= 1, "Array size: " + result.size());
            assertTrue(result.size() <= 2, "Array size: " + result.size());
            
            if (result.size() >= 1) {
                assertTrue(result.get(0).isTextual());
            }
            
            if (result.size() >= 2) {
                assertTrue(result.get(1).isInt());
                int age = result.get(1).asInt();
                assertTrue(age >= 18 && age <= 100);
            }
        }
    }
    
    // ==================== OBJECT GENERATOR TESTS ====================
    
    @Test
    public void testObjectGeneratorWithRequiredProperties() throws Exception {
        String schema = "{\n" +
                "  \"type\": \"object\",\n" +
                "  \"properties\": {\n" +
                "    \"id\": {\n" +
                "      \"type\": \"string\",\n" +
                "      \"format\": \"uuid\"\n" +
                "    },\n" +
                "    \"name\": {\n" +
                "      \"type\": \"string\",\n" +
                "      \"format\": \"name\"\n" +
                "    },\n" +
                "    \"email\": {\n" +
                "      \"type\": \"string\",\n" +
                "      \"format\": \"email\"\n" +
                "    },\n" +
                "    \"age\": {\n" +
                "      \"type\": \"integer\",\n" +
                "      \"minimum\": 18,\n" +
                "      \"maximum\": 100\n" +
                "    }\n" +
                "  },\n" +
                "  \"required\": [\"id\", \"name\", \"email\"]\n" +
                "}";
        
        JsonNode schemaNode = objectMapper.readTree(schema);
        ObjectGenerator generator = new ObjectGenerator(config, schemaNode, factory, options, faker);
        
        for (int i = 0; i < 50; i++) {
            JsonNode result = generator.generate();
            assertNotNull(result);
            assertTrue(result.isObject());
            
            // Check required properties
            assertTrue(result.has("id"));
            assertTrue(result.has("name"));
            assertTrue(result.has("email"));
            
            // Check property types
            assertTrue(result.get("id").isTextual());
            assertTrue(result.get("name").isTextual());
            assertTrue(result.get("email").isTextual());
            assertTrue(result.get("email").asText().contains("@"));
            
            // Check optional property if present
            if (result.has("age")) {
                assertTrue(result.get("age").isInt());
                int age = result.get("age").asInt();
                assertTrue(age >= 18 && age <= 100);
            }
        }
    }
    
    @Test
    public void testObjectGeneratorWithAdditionalProperties() throws Exception {
        String schema = "{\n" +
                "  \"type\": \"object\",\n" +
                "  \"properties\": {\n" +
                "    \"name\": {\n" +
                "      \"type\": \"string\"\n" +
                "    }\n" +
                "  },\n" +
                "  \"additionalProperties\": {\n" +
                "    \"type\": \"string\"\n" +
                "  }\n" +
                "}";
        
        JsonNode schemaNode = objectMapper.readTree(schema);
        ObjectGenerator generator = new ObjectGenerator(config, schemaNode, factory, options, faker);
        
        for (int i = 0; i < 20; i++) {
            JsonNode result = generator.generate();
            assertNotNull(result);
            assertTrue(result.isObject());
            
            // Check that all properties are strings
            for (JsonNode value : result) {
                assertTrue(value.isTextual());
            }
        }
    }
    
    // ==================== NULL GENERATOR TESTS ====================
    
    @Test
    public void testNullGenerator() throws Exception {
        String schema = "{\n" +
                "  \"type\": \"null\"\n" +
                "}";
        
        JsonNode schemaNode = objectMapper.readTree(schema);
        NullGenerator generator = new NullGenerator(config, schemaNode, options, faker);
        
        JsonNode result = generator.generate();
        assertNotNull(result);
        assertTrue(result.isNull());
    }
    
    // ==================== EDGE CASE TESTS ====================
    
    @Test
    public void testStringGeneratorWithZeroLength() throws Exception {
        String schema = "{\n" +
                "  \"type\": \"string\",\n" +
                "  \"minLength\": 0,\n" +
                "  \"maxLength\": 0\n" +
                "}";
        
        JsonNode schemaNode = objectMapper.readTree(schema);
        StringGenerator generator = new StringGenerator(config, schemaNode, options, faker);
        
        JsonNode result = generator.generate();
        assertNotNull(result);
        assertTrue(result.isTextual());
        assertEquals("", result.asText());
    }
    
    @Test
    public void testNumberGeneratorWithExclusiveMinMax() throws Exception {
        String schema = "{\n" +
                "  \"type\": \"number\",\n" +
                "  \"exclusiveMinimum\": 10.0,\n" +
                "  \"exclusiveMaximum\": 100.0\n" +
                "}";
        
        JsonNode schemaNode = objectMapper.readTree(schema);
        NumberGenerator generator = new NumberGenerator(config, schemaNode, options, faker);
        
        for (int i = 0; i < 50; i++) {
            JsonNode result = generator.generate();
            assertNotNull(result);
            assertTrue(result.isDouble());
            double value = result.asDouble();
            assertTrue(value > 10.0);
            assertTrue(value < 100.0);
        }
    }
    
    @Test
    public void testArrayGeneratorWithUniqueItems() throws Exception {
        String schema = "{\n" +
                "  \"type\": \"array\",\n" +
                "  \"items\": {\n" +
                "    \"type\": \"string\",\n" +
                "    \"enum\": [\"a\", \"b\", \"c\"]\n" +
                "  },\n" +
                "  \"minItems\": 1,\n" +
                "  \"maxItems\": 3,\n" +
                "  \"uniqueItems\": true\n" +
                "}";
        
        JsonNode schemaNode = objectMapper.readTree(schema);
        ArrayGenerator generator = new ArrayGenerator(config, schemaNode, factory, options, faker);
        
        for (int i = 0; i < 20; i++) {
            JsonNode result = generator.generate();
            assertNotNull(result);
            assertTrue(result.isArray());
            assertTrue(result.size() >= 1);
            assertTrue(result.size() <= 3);
            
            // Check uniqueness
            for (int j = 0; j < result.size(); j++) {
                for (int k = j + 1; k < result.size(); k++) {
                    assertNotEquals(result.get(j).asText(), 
                                   result.get(k).asText());
                }
            }
        }
    }
    
    @Test
    public void testGeneratorCanHandle() throws Exception {
        String stringSchema = "{\n" +
                "  \"type\": \"string\"\n" +
                "}";
        
        String numberSchema = "{\n" +
                "  \"type\": \"number\"\n" +
                "}";
        
        JsonNode stringSchemaNode = objectMapper.readTree(stringSchema);
        JsonNode numberSchemaNode = objectMapper.readTree(numberSchema);
        
        // Create other schema nodes for testing
        String booleanSchema = "{\"type\": \"boolean\"}";
        String arraySchema = "{\"type\": \"array\", \"items\": {\"type\": \"string\"}}";
        String objectSchema = "{\"type\": \"object\", \"properties\": {\"name\": {\"type\": \"string\"}}}";
        String nullSchema = "{\"type\": \"null\"}";
        
        JsonNode booleanSchemaNode = objectMapper.readTree(booleanSchema);
        JsonNode arraySchemaNode = objectMapper.readTree(arraySchema);
        JsonNode objectSchemaNode = objectMapper.readTree(objectSchema);
        JsonNode nullSchemaNode = objectMapper.readTree(nullSchema);
        
        StringGenerator stringGenerator = new StringGenerator(config, stringSchemaNode, options, faker);
        NumberGenerator numberGenerator = new NumberGenerator(config, numberSchemaNode, options, faker);
        BooleanGenerator booleanGenerator = new BooleanGenerator(config, booleanSchemaNode, options, faker);
        ArrayGenerator arrayGenerator = new ArrayGenerator(config, arraySchemaNode, factory, options, faker);
        ObjectGenerator objectGenerator = new ObjectGenerator(config, objectSchemaNode, factory, options, faker);
        NullGenerator nullGenerator = new NullGenerator(config, nullSchemaNode, options, faker);
        
        assertTrue(stringGenerator.canHandle(stringSchemaNode));
        assertTrue(numberGenerator.canHandle(numberSchemaNode));
        assertTrue(booleanGenerator.canHandle(booleanSchemaNode));
        assertTrue(arrayGenerator.canHandle(arraySchemaNode));
        assertTrue(objectGenerator.canHandle(objectSchemaNode));
        assertTrue(nullGenerator.canHandle(nullSchemaNode));
    }
}