Aprenda Testing Configuration with JUnit | Advanced Java Configuration Techniques

When building robust Java applications, you need to ensure that your configuration files contain all required values and that those values are valid. Automated testing with JUnit helps you catch configuration problems before they cause failures in production. By writing tests that check for the presence and correctness of properties, you can prevent common issues such as missing database URLs, malformed email addresses, or invalid port numbers.

To write a JUnit test for configuration, start by loading the properties file within the test method. Then, use assertions to check that each required property exists and that its value matches the expected format or range. For example, you may want to assert that a property is not null, that a port number falls within a valid range, or that a URL is syntactically correct. JUnit’s assertion methods such as assertNotNull, assertEquals, and assertTrue are commonly used for these checks.

ConfigTest.java

config.properties


              123456789101112131415161718192021222324252627282930313233
            
package com.example;

import org.junit.jupiter.api.Test;
import java.util.Properties;
import java.io.InputStream;
import static org.junit.jupiter.api.Assertions.*;

public class ConfigTest {

    @Test
    void testDatabaseConfigProperties() throws Exception {
        Properties props = new Properties();
        try (InputStream in = getClass().getClassLoader().getResourceAsStream("config.properties")) {
            assertNotNull(in, "config.properties file should be present");
            props.load(in);
        }

        String dbUrl = props.getProperty("db.url");
        String dbUser = props.getProperty("db.user");
        String dbPort = props.getProperty("db.port");

        assertNotNull(dbUrl, "db.url property should be set");
        assertTrue(dbUrl.startsWith("jdbc:"), "db.url should start with 'jdbc:'");

        assertNotNull(dbUser, "db.user property should be set");
        assertFalse(dbUser.trim().isEmpty(), "db.user should not be empty");

        assertNotNull(dbPort, "db.port property should be set");
        int port = Integer.parseInt(dbPort);
        assertTrue(port > 1024 && port < 65536, "db.port should be a valid port number");
    }
}

Testing configuration is not just about verifying a single set of values. Many Java applications use different configuration profiles for environments such as development, testing, and production. To test these profiles, you can parameterize your JUnit tests or use separate test resources for each profile. Always ensure that your tests cover scenarios where values might be missing or invalid. For instance, you might simulate a missing properties file or a property with an invalid format to verify that your application handles these cases gracefully—perhaps by using default values or by failing with a clear error message.

A robust testing strategy includes tests for fallback mechanisms. If your application is designed to load configuration from multiple sources (such as a primary file and a fallback default), your tests should confirm that the fallback is used when the primary source is unavailable or incomplete.

FallbackConfigTest.java

default-config.properties

primary-config.properties


              12345678910111213141516171819202122232425262728293031323334
            
package com.example;

import org.junit.jupiter.api.Test;
import java.util.Properties;
import java.io.InputStream;
import static org.junit.jupiter.api.Assertions.*;

public class FallbackConfigTest {

    private Properties loadProperties(String resourceName) throws Exception {
        Properties props = new Properties();
        try (InputStream in = getClass().getClassLoader().getResourceAsStream(resourceName)) {
            if (in != null) {
                props.load(in);
            }
        }
        return props;
    }

    @Test
    void testFallbackToDefaultConfig() throws Exception {
        Properties primary = loadProperties("primary-config.properties");
        Properties fallback = loadProperties("default-config.properties");

        String apiEndpoint = primary.getProperty("api.endpoint");
        if (apiEndpoint == null || apiEndpoint.trim().isEmpty()) {
            apiEndpoint = fallback.getProperty("api.endpoint");
        }

        assertNotNull(apiEndpoint, "api.endpoint should be present in either primary or default config");
        assertTrue(apiEndpoint.startsWith("https://"), "api.endpoint should start with 'https://'");
    }
}

1. Why is it important to test configuration files?

2. Which JUnit annotation is used to mark a test method?

Tudo estava claro?

Obrigado pelo seu feedback!

Seção 3. Capítulo 4

Pergunte à IA

Pergunte o que quiser ou experimente uma das perguntas sugeridas para iniciar nosso bate-papo

Deslize para mostrar o menu