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

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

import com.github.jsonschemafaker.options.Options;
import com.github.jsonschemafaker.FakerConfig;
import org.junit.jupiter.api.Test;

import java.util.Locale;
import java.util.Random;

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

/**
 * Comprehensive tests for the Options class.
 */
public class OptionsTest {
    
    @Test
    public void testDefaultOptions() {
        Options options = new Options();
        
        assertEquals(Locale.ENGLISH, options.getLocale());
        assertTrue(options.isUseDefaultValues());
        assertTrue(options.isGenerateOptionalProperties());
        assertEquals(10, options.getMaxArrayLength());
        assertEquals(1, options.getMinArrayLength());
        assertEquals(100, options.getMaxStringLength());
        assertEquals(1, options.getMinStringLength());
        assertTrue(options.isUseExamples());
        assertTrue(options.isUseEnumValues());
        assertFalse(options.isGenerateNullValues());
        assertEquals(0.1, options.getNullProbability(), 0.001);
        assertFalse(options.isUniqueItems());
        assertTrue(options.isUsePatterns());
        assertTrue(options.isUseFormats());
        assertTrue(options.isUseMinimum());
        assertTrue(options.isUseMaximum());
        assertTrue(options.isUseMultipleOf());
        assertTrue(options.isUseProperties());
        assertTrue(options.isUseAdditionalProperties());
        assertTrue(options.isUsePatternProperties());
        assertTrue(options.isUseDependencies());
        assertTrue(options.isUsePropertyDependencies());
        assertTrue(options.isUseAllOf());
        assertTrue(options.isUseAnyOf());
        assertTrue(options.isUseOneOf());
        assertTrue(options.isUseIfThenElse());
        assertTrue(options.isUseNot());
        assertTrue(options.isResolveReferences());
        assertTrue(options.isUseDefinitions());
        assertTrue(options.isUseComponents());
        assertTrue(options.isUseFaker());
        assertEquals("en", options.getFakerLocale());
        assertNotNull(options.getRandom());
        assertTrue(options.isUseCustomGenerators());
        assertTrue(options.isUseCustomFormats());
        assertTrue(options.isUseCustomTypes());
        assertFalse(options.isValidateSchema());
        assertFalse(options.isStrictMode());
        assertTrue(options.isIgnoreUnknownFormats());
    }
    
    @Test
    public void testOptionsFromFakerConfig() {
        FakerConfig config = FakerConfig.builder()
                .locale(Locale.FRENCH)
                .maxArrayLength(20)
                .minArrayLength(5)
                .maxStringLength(200)
                .minStringLength(10)
                .useDefaultValues(false)
                .generateOptionalProperties(false)
                .useExamples(false)
                .useEnumValues(false)
                .generateNullValues(true)
                .nullProbability(0.5)
                .build();
        
        Options options = new Options(config);
        
        assertEquals(Locale.FRENCH, options.getLocale());
        assertFalse(options.isUseDefaultValues());
        assertFalse(options.isGenerateOptionalProperties());
        assertEquals(20, options.getMaxArrayLength());
        assertEquals(5, options.getMinArrayLength());
        assertEquals(200, options.getMaxStringLength());
        assertEquals(10, options.getMinStringLength());
        assertFalse(options.isUseExamples());
        assertFalse(options.isUseEnumValues());
        assertTrue(options.isGenerateNullValues());
        assertEquals(0.5, options.getNullProbability(), 0.001);
    }
    
    @Test
    public void testOptionsBuilder() {
        Random customRandom = new Random(12345);
        
        Options options = Options.builder()
                .locale(Locale.GERMAN)
                .maxArrayLength(15)
                .minArrayLength(3)
                .maxStringLength(150)
                .minStringLength(5)
                .useDefaultValues(false)
                .generateOptionalProperties(false)
                .useExamples(false)
                .useEnumValues(false)
                .generateNullValues(true)
                .nullProbability(0.3)
                .uniqueItems(true)
                .usePatterns(false)
                .useFormats(false)
                .useMinimum(false)
                .useMaximum(false)
                .useMultipleOf(false)
                .useProperties(false)
                .useAdditionalProperties(false)
                .usePatternProperties(false)
                .useDependencies(false)
                .usePropertyDependencies(false)
                .useAllOf(false)
                .useAnyOf(false)
                .useOneOf(false)
                .useIfThenElse(false)
                .useNot(false)
                .resolveReferences(false)
                .useDefinitions(false)
                .useComponents(false)
                .useFaker(false)
                .fakerLocale("de")
                .random(customRandom)
                .useCustomGenerators(false)
                .useCustomFormats(false)
                .useCustomTypes(false)
                .validateSchema(true)
                .strictMode(true)
                .ignoreUnknownFormats(false)
                .build();
        
        assertEquals(Locale.GERMAN, options.getLocale());
        assertEquals(15, options.getMaxArrayLength());
        assertEquals(3, options.getMinArrayLength());
        assertEquals(150, options.getMaxStringLength());
        assertEquals(5, options.getMinStringLength());
        assertFalse(options.isUseDefaultValues());
        assertFalse(options.isGenerateOptionalProperties());
        assertFalse(options.isUseExamples());
        assertFalse(options.isUseEnumValues());
        assertTrue(options.isGenerateNullValues());
        assertEquals(0.3, options.getNullProbability(), 0.001);
        assertTrue(options.isUniqueItems());
        assertFalse(options.isUsePatterns());
        assertFalse(options.isUseFormats());
        assertFalse(options.isUseMinimum());
        assertFalse(options.isUseMaximum());
        assertFalse(options.isUseMultipleOf());
        assertFalse(options.isUseProperties());
        assertFalse(options.isUseAdditionalProperties());
        assertFalse(options.isUsePatternProperties());
        assertFalse(options.isUseDependencies());
        assertFalse(options.isUsePropertyDependencies());
        assertFalse(options.isUseAllOf());
        assertFalse(options.isUseAnyOf());
        assertFalse(options.isUseOneOf());
        assertFalse(options.isUseIfThenElse());
        assertFalse(options.isUseNot());
        assertFalse(options.isResolveReferences());
        assertFalse(options.isUseDefinitions());
        assertFalse(options.isUseComponents());
        assertFalse(options.isUseFaker());
        assertEquals("de", options.getFakerLocale());
        assertEquals(customRandom, options.getRandom());
        assertFalse(options.isUseCustomGenerators());
        assertFalse(options.isUseCustomFormats());
        assertFalse(options.isUseCustomTypes());
        assertTrue(options.isValidateSchema());
        assertTrue(options.isStrictMode());
        assertFalse(options.isIgnoreUnknownFormats());
    }
    
    @Test
    public void testOptionsBuilderWithExistingOptions() {
        Options originalOptions = Options.builder()
                .locale(Locale.ITALIAN)
                .maxArrayLength(25)
                .build();
        
        Options newOptions = Options.builder(originalOptions)
                .minArrayLength(8)
                .useDefaultValues(false)
                .build();
        
        assertEquals(Locale.ITALIAN, newOptions.getLocale());
        assertEquals(25, newOptions.getMaxArrayLength());
        assertEquals(8, newOptions.getMinArrayLength());
        assertFalse(newOptions.isUseDefaultValues());
    }
    
    @Test
    public void testOptionsSetters() {
        Options options = new Options();
        Random customRandom = new Random(54321);
        
        options.setLocale(new Locale("es"));
        options.setMaxArrayLength(30);
        options.setMinArrayLength(7);
        options.setMaxStringLength(300);
        options.setMinStringLength(15);
        options.setUseDefaultValues(false);
        options.setGenerateOptionalProperties(false);
        options.setUseExamples(false);
        options.setUseEnumValues(false);
        options.setGenerateNullValues(true);
        options.setNullProbability(0.7);
        options.setUniqueItems(true);
        options.setUsePatterns(false);
        options.setUseFormats(false);
        options.setUseMinimum(false);
        options.setUseMaximum(false);
        options.setUseMultipleOf(false);
        options.setUseProperties(false);
        options.setUseAdditionalProperties(false);
        options.setUsePatternProperties(false);
        options.setUseDependencies(false);
        options.setUsePropertyDependencies(false);
        options.setUseAllOf(false);
        options.setUseAnyOf(false);
        options.setUseOneOf(false);
        options.setUseIfThenElse(false);
        options.setUseNot(false);
        options.setResolveReferences(false);
        options.setUseDefinitions(false);
        options.setUseComponents(false);
        options.setUseFaker(false);
        options.setFakerLocale("es");
        options.setRandom(customRandom);
        options.setUseCustomGenerators(false);
        options.setUseCustomFormats(false);
        options.setUseCustomTypes(false);
        options.setValidateSchema(true);
        options.setStrictMode(true);
        options.setIgnoreUnknownFormats(false);
        
        assertEquals(new Locale("es"), options.getLocale());
        assertEquals(30, options.getMaxArrayLength());
        assertEquals(7, options.getMinArrayLength());
        assertEquals(300, options.getMaxStringLength());
        assertEquals(15, options.getMinStringLength());
        assertFalse(options.isUseDefaultValues());
        assertFalse(options.isGenerateOptionalProperties());
        assertFalse(options.isUseExamples());
        assertFalse(options.isUseEnumValues());
        assertTrue(options.isGenerateNullValues());
        assertEquals(0.7, options.getNullProbability(), 0.001);
        assertTrue(options.isUniqueItems());
        assertFalse(options.isUsePatterns());
        assertFalse(options.isUseFormats());
        assertFalse(options.isUseMinimum());
        assertFalse(options.isUseMaximum());
        assertFalse(options.isUseMultipleOf());
        assertFalse(options.isUseProperties());
        assertFalse(options.isUseAdditionalProperties());
        assertFalse(options.isUsePatternProperties());
        assertFalse(options.isUseDependencies());
        assertFalse(options.isUsePropertyDependencies());
        assertFalse(options.isUseAllOf());
        assertFalse(options.isUseAnyOf());
        assertFalse(options.isUseOneOf());
        assertFalse(options.isUseIfThenElse());
        assertFalse(options.isUseNot());
        assertFalse(options.isResolveReferences());
        assertFalse(options.isUseDefinitions());
        assertFalse(options.isUseComponents());
        assertFalse(options.isUseFaker());
        assertEquals("es", options.getFakerLocale());
        assertEquals(customRandom, options.getRandom());
        assertFalse(options.isUseCustomGenerators());
        assertFalse(options.isUseCustomFormats());
        assertFalse(options.isUseCustomTypes());
        assertTrue(options.isValidateSchema());
        assertTrue(options.isStrictMode());
        assertFalse(options.isIgnoreUnknownFormats());
    }
    
    @Test
    public void testOptionsEdgeCases() {
        Options options = new Options();
        
        // Test boundary values
        options.setMaxArrayLength(0);
        options.setMinArrayLength(0);
        options.setMaxStringLength(0);
        options.setMinStringLength(0);
        options.setNullProbability(0.0);
        
        assertEquals(0, options.getMaxArrayLength());
        assertEquals(0, options.getMinArrayLength());
        assertEquals(0, options.getMaxStringLength());
        assertEquals(0, options.getMinStringLength());
        assertEquals(0.0, options.getNullProbability(), 0.001);
        
        // Test maximum values
        options.setMaxArrayLength(Integer.MAX_VALUE);
        options.setMaxStringLength(Integer.MAX_VALUE);
        options.setNullProbability(1.0);
        
        assertEquals(Integer.MAX_VALUE, options.getMaxArrayLength());
        assertEquals(Integer.MAX_VALUE, options.getMaxStringLength());
        assertEquals(1.0, options.getNullProbability(), 0.001);
    }
    
    @Test
    public void testOptionsThreadSafety() throws Exception {
        Options options = new Options();
        
        int threadCount = 10;
        int operationsPerThread = 1000;
        
        Thread[] threads = new Thread[threadCount];
        
        for (int i = 0; i < threadCount; i++) {
            final int threadId = i;
            threads[i] = new Thread(() -> {
                for (int j = 0; j < operationsPerThread; j++) {
                    options.setMaxArrayLength(threadId + j);
                    options.setMinArrayLength(threadId + j);
                    options.setMaxStringLength(threadId + j);
                    options.setMinStringLength(threadId + j);
                    options.setNullProbability((threadId + j) % 100 / 100.0);
                    options.setUseDefaultValues(j % 2 == 0);
                    options.setGenerateOptionalProperties(j % 2 == 1);
                    
                    // Read values
                    int maxArray = options.getMaxArrayLength();
                    int minArray = options.getMinArrayLength();
                    int maxString = options.getMaxStringLength();
                    int minString = options.getMinStringLength();
                    double nullProb = options.getNullProbability();
                    boolean useDefaults = options.isUseDefaultValues();
                    boolean generateOptional = options.isGenerateOptionalProperties();
                    
                    // Verify values are reasonable
                    assertTrue(maxArray >= 0);
                    assertTrue(minArray >= 0);
                    assertTrue(maxString >= 0);
                    assertTrue(minString >= 0);
                    assertTrue(nullProb >= 0.0 && nullProb <= 1.0);
                }
            });
        }
        
        // Start all threads
        for (Thread thread : threads) {
            thread.start();
        }
        
        // Wait for all threads to complete
        for (Thread thread : threads) {
            thread.join();
        }
        
        // Verify final state is reasonable
        assertTrue(options.getMaxArrayLength() >= 0);
        assertTrue(options.getMinArrayLength() >= 0);
        assertTrue(options.getMaxStringLength() >= 0);
        assertTrue(options.getMinStringLength() >= 0);
        assertTrue(options.getNullProbability() >= 0.0 && options.getNullProbability() <= 1.0);
    }
}