# How to Read Configuration from Properties Files Using PropertiesHelpers in the Selenium Automation Framework

> Effortlessly read .properties files in Selenium with PropertiesHelpers from anhtester/automationframeworkselenium. Simplify configuration management for your automation framework.

- Repository: [Anh Tester/automationframeworkselenium](https://github.com/anhtester/automationframeworkselenium)
- Tags: how-to-guide
- Published: 2026-02-24

---

**Use the static `PropertiesHelpers` utility class in `anhtester/automationframeworkselenium` to load, retrieve, and update Java `.properties` files without writing manual I/O code.**

The **Automation Framework Selenium** (hosted at `anhtester/automationframeworkselenium`) centralizes environment-specific settings—such as URLs, browser types, and wait times—inside standard Java properties files. The `PropertiesHelpers` class, located at [`src/main/java/com/anhtester/helpers/PropertiesHelpers.java`](https://github.com/anhtester/automationframeworkselenium/blob/main/src/main/java/com/anhtester/helpers/PropertiesHelpers.java), exposes static methods that handle file loading, UTF-8 encoding conversion, and runtime updates, letting test classes access configuration through simple one-line calls.

## Understanding the PropertiesHelpers Architecture

The `PropertiesHelpers` utility manages a static `java.util.Properties` instance cached in the private field `properties`. This design ensures that once files are loaded, subsequent reads operate from memory rather than hitting the disk repeatedly. The class also maintains a `linkFile` string that stores the absolute path to the default configuration file, resolved via `SystemHelpers.getCurrentDir()`.

All methods are **static**, so you never instantiate the class; you simply call `PropertiesHelpers.methodName()` from any test class.

## Loading Properties Files

The framework supports two loading strategies depending on whether you need the entire configuration suite or just the primary defaults.

### Load All Configuration Files

The **`loadAllFiles()`** method merges multiple properties files into a single `Properties` object. It reads the hard-coded list including `config.properties`, `data.properties`, and CRM locator files from `src/test/resources/config/`.

```java
// Load and merge all framework properties at suite startup
PropertiesHelpers.loadAllFiles();

```

### Load Only the Default File

If your test requires only the primary configuration, call **`setDefaultFile()`**. This loads `src/test/resources/config/config.properties` and initializes the `linkFile` reference used by later write operations.

```java
// Initialize with only the default config file
PropertiesHelpers.setDefaultFile();

```

Both methods automatically resolve absolute paths using the project directory, ensuring compatibility across different execution environments.

## Retrieving Configuration Values

Fetch any property value using the **`getValue(String key)`** method. The implementation follows a lazy-loading pattern: if `properties` is null, it automatically invokes `setDefaultFile()` before looking up the key.

```java
// Retrieve the CRM application URL
String crmUrl = PropertiesHelpers.getValue("URL_CRM");
driver.get(crmUrl);

// Get timeout settings
String timeout = PropertiesHelpers.getValue("PAGE_LOAD_TIMEOUT");

```

Internally, `getValue` performs three steps:
1. Checks if the static `properties` field is initialized; if not, loads the default file
2. Retrieves the raw value using `properties.getProperty(key)`
3. Returns the string processed through `LanguageUtils.convertCharset_ISO_8859_1_To_UTF8` to ensure proper UTF-8 encoding for international characters

## Updating Properties at Runtime

To modify configuration values dynamically—useful for switching browsers or toggling feature flags mid-suite—use the **`setValue(String key, String value)`** method. This writes the updated key-value pair back to the file referenced by `linkFile` using `Properties.store()`.

```java
// Override the browser type for the current test execution
PropertiesHelpers.setValue("BROWSER", "firefox");

// Verify the update immediately
String currentBrowser = PropertiesHelpers.getValue("BROWSER");
System.out.println("Browser configured as: " + currentBrowser);

```

The method ensures the default file is loaded before attempting any write operation, preventing null pointer exceptions.

## Complete Test Implementation Example

Below is a practical test class demonstrating the full lifecycle: loading configuration, reading values, and updating settings at runtime.

```java
import com.anhtester.helpers.PropertiesHelpers;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;

public class ConfigurationExampleTest extends BaseTest {

    @BeforeClass
    public void initializeConfig() {
        // Load all properties files once before any test runs
        PropertiesHelpers.loadAllFiles();
        
        // Navigate using the configured URL
        String applicationUrl = PropertiesHelpers.getValue("URL_CRM");
        driver.get(applicationUrl);
    }

    @Test
    public void verifyDynamicConfiguration() {
        // Read original value
        String originalBrowser = PropertiesHelpers.getValue("BROWSER");
        System.out.println("Original browser: " + originalBrowser);
        
        // Update configuration at runtime
        PropertiesHelpers.setValue("BROWSER", "edge");
        
        // Confirm the change persists in the properties object
        String updatedBrowser = PropertiesHelpers.getValue("BROWSER");
        assert updatedBrowser.equals("edge") : "Browser configuration update failed";
    }
}

```

## Configuration File Locations

The framework expects properties files in specific resource directories:

- **`src/test/resources/config/config.properties`** – Primary framework settings (browser, URLs, timeouts)
- **`src/test/resources/config/data.properties`** – Auxiliary test data and credentials
- **`src/test/resources/objects/crm_locators.properties`** – UI element locators for the CRM module

All paths are resolved relative to the project root using `SystemHelpers.getCurrentDir()`, making the framework portable across CI/CD pipelines and local development environments.

## Summary

- **PropertiesHelpers** ([`src/main/java/com/anhtester/helpers/PropertiesHelpers.java`](https://github.com/anhtester/automationframeworkselenium/blob/main/src/main/java/com/anhtester/helpers/PropertiesHelpers.java)) provides static methods for properties management in the anhtester/automationframeworkselenium repository.
- **`loadAllFiles()`** merges multiple configuration files; **`setDefaultFile()`** loads only the primary config.
- **`getValue(key)`** retrieves UTF-8 decoded values and auto-initializes the properties cache if empty.
- **`setValue(key, value)`** writes changes back to disk, enabling runtime configuration overrides.
- All file paths are resolved dynamically via `SystemHelpers.getCurrentDir()`, ensuring cross-platform compatibility.

## Frequently Asked Questions

### How does PropertiesHelpers handle file encoding?

The `getValue` method passes every retrieved value through `LanguageUtils.convertCharset_ISO_8859_1_To_UTF8`, ensuring that special characters and non-ASCII text stored in ISO-8859-1 format are correctly converted to UTF-8 before returning to the test code.

### Can I load custom properties files not defined in the framework?

The current implementation in [`PropertiesHelpers.java`](https://github.com/anhtester/automationframeworkselenium/blob/main/PropertiesHelpers.java) hard-codes the file list within `loadAllFiles()`. To load additional custom files, you would need to extend the class or modify the `loadAllFiles()` method to accept a file path parameter, as the static `properties` field is private.

### Is PropertiesHelpers thread-safe for parallel test execution?

Because the `properties` field is static and shared across the JVM, concurrent updates via `setValue()` in parallel threads could lead to race conditions. For thread-safe configuration in parallel execution, load properties once in a `@BeforeSuite` method and treat the configuration as read-only during test runs.

### What happens if I call getValue before loading any files?

The `getValue` method implements lazy initialization: if the static `properties` variable is null, it automatically invokes `setDefaultFile()` to load `src/test/resources/config/config.properties` before attempting to retrieve the requested key.