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

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

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

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

/**
 * Test class for JsonSchemaFaker functionality.
 */
public class JsonSchemaFakerTest {
    
    private JsonSchemaFaker faker;
    private ObjectMapper objectMapper;
    
    @BeforeEach
    public void setUp() {
        faker = new JsonSchemaFaker();
        objectMapper = new ObjectMapper();
    }
    
    @Test
    public void testBasicStringGeneration() throws Exception {
        String schema = "{\n" +
                "  \"type\": \"string\",\n" +
                "  \"minLength\": 5,\n" +
                "  \"maxLength\": 10\n" +
                "}";
        
        JsonNode result = faker.generate(schema);
        assertNotNull(result);
        assertTrue(result.isTextual());
        assertTrue(result.asText().length() >= 5);
        assertTrue(result.asText().length() <= 10);
    }
    
    @Test
    public void testStringWithFormat() throws Exception {
        String schema = "{\n" +
                "  \"type\": \"string\",\n" +
                "  \"format\": \"email\"\n" +
                "}";
        
        JsonNode result = faker.generate(schema);
        assertNotNull(result);
        assertTrue(result.isTextual());
        assertTrue(result.asText().contains("@"));
    }
    
    @Test
    public void testIntegerGeneration() throws Exception {
        String schema = "{\n" +
                "  \"type\": \"integer\",\n" +
                "  \"minimum\": 1,\n" +
                "  \"maximum\": 100\n" +
                "}";
        
        JsonNode result = faker.generate(schema);
        assertNotNull(result);
        assertTrue(result.isInt());
        assertTrue(result.asInt() >= 1);
        assertTrue(result.asInt() <= 100);
    }
    
    @Test
    public void testNumberGeneration() throws Exception {
        String schema = "{\n" +
                "  \"type\": \"number\",\n" +
                "  \"minimum\": 0.0,\n" +
                "  \"maximum\": 1.0\n" +
                "}";
        
        JsonNode result = faker.generate(schema);
        assertNotNull(result);
        assertTrue(result.isDouble());
        assertTrue(result.asDouble() >= 0.0);
        assertTrue(result.asDouble() <= 1.0);
    }
    
    @Test
    public void testBooleanGeneration() throws Exception {
        String schema = "{\n" +
                "  \"type\": \"boolean\"\n" +
                "}";
        
        JsonNode result = faker.generate(schema);
        assertNotNull(result);
        assertTrue(result.isBoolean());
    }
    
    @Test
    public void testArrayGeneration() throws Exception {
        String schema = "{\n" +
                "  \"type\": \"array\",\n" +
                "  \"items\": {\n" +
                "    \"type\": \"string\"\n" +
                "  },\n" +
                "  \"minItems\": 2,\n" +
                "  \"maxItems\": 5\n" +
                "}";
        
        JsonNode result = faker.generate(schema);
        assertNotNull(result);
        assertTrue(result.isArray());
        assertTrue(result.size() >= 2);
        assertTrue(result.size() <= 5);
        
        for (JsonNode item : result) {
            assertTrue(item.isTextual());
        }
    }
    
    @Test
    public void testObjectGeneration() throws Exception {
        String schema = "{\n" +
                "  \"type\": \"object\",\n" +
                "  \"properties\": {\n" +
                "    \"name\": {\n" +
                "      \"type\": \"string\"\n" +
                "    },\n" +
                "    \"age\": {\n" +
                "      \"type\": \"integer\",\n" +
                "      \"minimum\": 18,\n" +
                "      \"maximum\": 65\n" +
                "    }\n" +
                "  },\n" +
                "  \"required\": [\"name\", \"age\"]\n" +
                "}";
        
        JsonNode result = faker.generate(schema);
        assertNotNull(result);
        assertTrue(result.isObject());
        assertTrue(result.has("name"));
        assertTrue(result.has("age"));
        assertTrue(result.get("name").isTextual());
        assertTrue(result.get("age").isInt());
        assertTrue(result.get("age").asInt() >= 18);
        assertTrue(result.get("age").asInt() <= 65);
    }
    
    @Test
    public void testEnumGeneration() throws Exception {
        String schema = "{\n" +
                "  \"type\": \"string\",\n" +
                "  \"enum\": [\"red\", \"green\", \"blue\"]\n" +
                "}";
        
        JsonNode result = faker.generate(schema);
        assertNotNull(result);
        assertTrue(result.isTextual());
        String value = result.asText();
        assertTrue(value.equals("red") || value.equals("green") || value.equals("blue"));
    }
    
    @Test
    public void testDefaultValue() throws Exception {
        String schema = "{\n" +
                "  \"type\": \"string\",\n" +
                "  \"default\": \"default-value\"\n" +
                "}";
        
        JsonNode result = faker.generate(schema);
        assertNotNull(result);
        assertTrue(result.isTextual());
        assertEquals("default-value", result.asText());
    }
    
    @Test
    public void testMultipleGeneration() throws Exception {
        String schema = "{\n" +
                "  \"type\": \"object\",\n" +
                "  \"properties\": {\n" +
                "    \"id\": {\n" +
                "      \"type\": \"integer\"\n" +
                "    },\n" +
                "    \"name\": {\n" +
                "      \"type\": \"string\"\n" +
                "    },\n" +
                "    \"active\": {\n" +
                "      \"type\": \"boolean\"\n" +
                "    }\n" +
                "  }\n" +
                "}";
        
        JsonNode result1 = faker.generate(schema);
        JsonNode result2 = faker.generate(schema);
        
        assertNotNull(result1);
        assertNotNull(result2);
        assertTrue(result1.isObject());
        assertTrue(result2.isObject());
        
        // Results should be different (random generation)
        assertNotEquals(result1.toString(), result2.toString());
    }
    
    @Test
    public void testGenerateAsMap() throws Exception {
        String schema = "{\n" +
                "  \"type\": \"object\",\n" +
                "  \"properties\": {\n" +
                "    \"name\": {\n" +
                "      \"type\": \"string\"\n" +
                "    },\n" +
                "    \"age\": {\n" +
                "      \"type\": \"integer\"\n" +
                "    }\n" +
                "  }\n" +
                "}";
        
        java.util.Map<String, Object> result = faker.generateAsMap(schema);
        assertNotNull(result);
        assertTrue(result.containsKey("name"));
        assertTrue(result.containsKey("age"));
        assertTrue(result.get("name") instanceof String);
        assertTrue(result.get("age") instanceof Integer);
    }
    
    @Test
    public void testComplexSchema() throws Exception {
        String schema = "{\n" +
                "  \"type\": \"object\",\n" +
                "  \"properties\": {\n" +
                "    \"user\": {\n" +
                "      \"type\": \"object\",\n" +
                "      \"properties\": {\n" +
                "        \"id\": {\n" +
                "          \"type\": \"integer\"\n" +
                "        },\n" +
                "        \"name\": {\n" +
                "          \"type\": \"string\"\n" +
                "        },\n" +
                "        \"email\": {\n" +
                "          \"type\": \"string\",\n" +
                "          \"format\": \"email\"\n" +
                "        },\n" +
                "        \"roles\": {\n" +
                "          \"type\": \"array\",\n" +
                "          \"items\": {\n" +
                "            \"type\": \"string\"\n" +
                "          },\n" +
                "          \"minItems\": 1,\n" +
                "          \"maxItems\": 3\n" +
                "        }\n" +
                "      },\n" +
                "      \"required\": [\"id\", \"name\", \"email\"]\n" +
                "    },\n" +
                "    \"metadata\": {\n" +
                "      \"type\": \"object\",\n" +
                "      \"properties\": {\n" +
                "        \"created\": {\n" +
                "          \"type\": \"string\",\n" +
                "          \"format\": \"date-time\"\n" +
                "        },\n" +
                "        \"version\": {\n" +
                "          \"type\": \"string\"\n" +
                "        }\n" +
                "      }\n" +
                "    }\n" +
                "  }\n" +
                "}";
        
        JsonNode result = faker.generate(schema);
        assertNotNull(result);
        assertTrue(result.isObject());
        assertTrue(result.has("user"));
        assertTrue(result.has("metadata"));
        
        JsonNode user = result.get("user");
        assertTrue(user.has("id"));
        assertTrue(user.has("name"));
        assertTrue(user.has("email"));
        assertTrue(user.has("roles"));
        
        assertTrue(user.get("id").isInt());
        assertTrue(user.get("name").isTextual());
        assertTrue(user.get("email").isTextual());
        assertTrue(user.get("email").asText().contains("@"));
        assertTrue(user.get("roles").isArray());
        assertTrue(user.get("roles").size() >= 1);
        assertTrue(user.get("roles").size() <= 3);
        
        JsonNode metadata = result.get("metadata");
        assertTrue(metadata.has("created"));
        assertTrue(metadata.has("version"));
        assertTrue(metadata.get("created").isTextual());
        assertTrue(metadata.get("version").isTextual());
    }
    
    @Test
    public void testReferenceResolution() throws Exception {
        String schema = "{\n" +
                "  \"definitions\": {\n" +
                "    \"User\": {\n" +
                "      \"type\": \"object\",\n" +
                "      \"properties\": {\n" +
                "        \"id\": {\n" +
                "          \"type\": \"integer\"\n" +
                "        },\n" +
                "        \"name\": {\n" +
                "          \"type\": \"string\"\n" +
                "        }\n" +
                "      }\n" +
                "    }\n" +
                "  },\n" +
                "  \"type\": \"object\",\n" +
                "  \"properties\": {\n" +
                "    \"user\": {\n" +
                "      \"$ref\": \"#/definitions/User\"\n" +
                "    }\n" +
                "  }\n" +
                "}";
        
        JsonNode result = faker.generate(schema);
        assertNotNull(result);
        assertTrue(result.isObject());
        assertTrue(result.has("user"));
        
        JsonNode user = result.get("user");
        assertTrue(user.has("id"));
        assertTrue(user.has("name"));
        assertTrue(user.get("id").isInt());
        assertTrue(user.get("name").isTextual());
    }
    
    @Test
    public void testArrayWithUniqueItems() throws Exception {
        String schema = "{\n" +
                "  \"type\": \"array\",\n" +
                "  \"items\": {\n" +
                "    \"type\": \"string\",\n" +
                "    \"enum\": [\"a\", \"b\", \"c\", \"d\"]\n" +
                "  },\n" +
                "  \"uniqueItems\": true,\n" +
                "  \"minItems\": 2,\n" +
                "  \"maxItems\": 4\n" +
                "}";
        
        JsonNode result = faker.generate(schema);
        assertNotNull(result);
        assertTrue(result.isArray());
        assertTrue(result.size() >= 2);
        assertTrue(result.size() <= 4);
        
        // Check for uniqueness
        java.util.Set<String> uniqueValues = new java.util.HashSet<>();
        for (JsonNode item : result) {
            assertTrue(item.isTextual());
            uniqueValues.add(item.asText());
        }
        assertEquals(result.size(), uniqueValues.size());
    }
    
    @Test
    public void testObjectWithAdditionalProperties() throws Exception {
        String schema = "{\n" +
                "  \"type\": \"object\",\n" +
                "  \"properties\": {\n" +
                "    \"name\": {\n" +
                "      \"type\": \"string\"\n" +
                "    }\n" +
                "  },\n" +
                "  \"additionalProperties\": {\n" +
                "    \"type\": \"string\"\n" +
                "  }\n" +
                "}";
        
        JsonNode result = faker.generate(schema);
        assertNotNull(result);
        assertTrue(result.isObject());
        assertTrue(result.has("name"));
        assertTrue(result.get("name").isTextual());
        
        // Additional properties should also be strings
        java.util.Iterator<java.util.Map.Entry<String, JsonNode>> fields = result.fields();
        while (fields.hasNext()) {
            java.util.Map.Entry<String, JsonNode> field = fields.next();
            if (!field.getKey().equals("name")) {
                assertTrue(field.getValue().isTextual());
            }
        }
    }
    
    @Test
    public void testNullGeneration() throws Exception {
        String schema = "{\n" +
                "  \"type\": \"null\"\n" +
                "}";
        
        JsonNode result = faker.generate(schema);
        assertNotNull(result);
        assertTrue(result.isNull());
    }
    
    @Test
    public void testOneOfGeneration() throws Exception {
        String schema = "{\n" +
                "  \"oneOf\": [\n" +
                "    {\n" +
                "      \"type\": \"string\"\n" +
                "    },\n" +
                "    {\n" +
                "      \"type\": \"integer\"\n" +
                "    }\n" +
                "  ]\n" +
                "}";
        
        JsonNode result = faker.generate(schema);
        assertNotNull(result);
        assertTrue(result.isTextual() || result.isInt());
    }
    
    @Test
    public void testAnyOfGeneration() throws Exception {
        String schema = "{\n" +
                "  \"anyOf\": [\n" +
                "    {\n" +
                "      \"type\": \"boolean\"\n" +
                "    },\n" +
                "    {\n" +
                "      \"type\": \"number\"\n" +
                "    }\n" +
                "  ]\n" +
                "}";
        
        JsonNode result = faker.generate(schema);
        assertNotNull(result);
        assertTrue(result.isBoolean() || result.isNumber());
    }
    
    @Test
    public void testAllOfGeneration() throws Exception {
        String schema = "{\n" +
                "  \"allOf\": [\n" +
                "    {\n" +
                "      \"type\": \"object\",\n" +
                "      \"properties\": {\n" +
                "        \"name\": {\n" +
                "          \"type\": \"string\"\n" +
                "        }\n" +
                "      }\n" +
                "    },\n" +
                "    {\n" +
                "      \"type\": \"object\",\n" +
                "      \"properties\": {\n" +
                "        \"age\": {\n" +
                "          \"type\": \"integer\"\n" +
                "        }\n" +
                "      }\n" +
                "    }\n" +
                "  ]\n" +
                "}";
        
        JsonNode result = faker.generate(schema);
        assertNotNull(result);
        assertTrue(result.isObject());
        assertTrue(result.has("name"));
        assertTrue(result.has("age"));
        assertTrue(result.get("name").isTextual());
        assertTrue(result.get("age").isInt());
    }
}