Properties file for configuration in Selenium Java - Deep Dive

Overview - Properties file for configuration

What is it?

A properties file is a simple text file used to store configuration settings as key-value pairs. In Selenium Java testing, it helps keep important data like URLs, browser types, and credentials separate from the test code. This makes tests easier to manage and update without changing the code itself. Properties files usually have a .properties extension and follow a simple format.

Why it matters

Without properties files, configuration details would be hardcoded inside test scripts, making them rigid and difficult to maintain. If you want to change a URL or switch browsers, you'd have to edit and recompile code. Properties files solve this by allowing testers to change settings quickly and safely, improving test flexibility and reducing errors. This saves time and effort in real testing projects.

Where it fits

Before learning properties files, you should understand basic Java programming and how Selenium tests work. After mastering properties files, you can learn about advanced configuration management like environment variables, YAML/JSON configs, or test data management frameworks.

Mental Model

Core Idea

A properties file is like a simple, external notebook where your test settings live, so your test code can read them anytime without hardcoding values.

Think of it like...

Imagine you have a recipe book (your test code) and a separate shopping list (properties file). Instead of writing ingredients inside the recipe, you keep them on the list. If you want to change an ingredient, you just update the list without rewriting the recipe.

┌─────────────────────┐
│   Properties File   │
│  key1=value1        │
│  key2=value2        │
│  ...                │
└─────────┬───────────┘
          │
          ▼
┌─────────────────────┐
│   Selenium Test     │
│  Reads keys & uses  │
│  values dynamically │
└─────────────────────┘

Build-Up - 6 Steps

1

Foundation

What is a Properties File

Concept: Introduce the basic idea of a properties file as a key-value text file for configuration.

A properties file is a plain text file with lines like key=value. For example: url=https://example.com browser=chrome username=testuser password=pass123 Each line stores a setting. The file ends with .properties extension. It is easy to read and edit with any text editor.

Result

You understand that properties files store simple settings outside code.

Knowing that configuration can live outside code helps separate concerns and makes tests easier to update.

2

Foundation

Loading Properties in Java

Concept: Learn how to load and read properties files in Java code.

In Java, use java.util.Properties class to load a properties file: Properties prop = new Properties(); try (FileInputStream fis = new FileInputStream("config.properties")) { prop.load(fis); } String url = prop.getProperty("url"); System.out.println(url); This code reads the file and fetches the value for key 'url'.

Result

The Java program prints the URL stored in the properties file.

Understanding how to load properties files lets you keep test settings flexible and external.

3

Intermediate

Using Properties in Selenium Tests

🤔Before reading on: do you think hardcoding URLs in tests or using properties files is better for maintenance? Commit to your answer.

Concept: Apply properties files to control Selenium test settings like browser type and URL.

Instead of writing: WebDriver driver = new ChromeDriver(); driver.get("https://example.com"); Use properties: String browser = prop.getProperty("browser"); if (browser.equalsIgnoreCase("chrome")) { driver = new ChromeDriver(); } else if (browser.equalsIgnoreCase("firefox")) { driver = new FirefoxDriver(); } driver.get(prop.getProperty("url")); This lets you switch browsers or URLs by editing the properties file only.

Result

Tests run on the browser and URL specified in the properties file, not hardcoded values.

Using properties files for Selenium settings makes tests adaptable and easier to run in different environments.

4

Intermediate

Best Practices for Properties Files

🤔Before reading on: do you think storing passwords in plain text properties files is safe? Commit to your answer.

Concept: Learn how to organize and secure properties files for real projects.

Keep properties files outside version control if they contain secrets. Use placeholders or environment variables for sensitive data. Group related settings logically, e.g., browser, URL, credentials. Use comments (#) to explain keys. Example: # Browser to use browser=chrome # Application URL url=https://example.com # Credentials (avoid storing real passwords here) username=testuser password=pass123 Avoid committing passwords in plain text.

Result

You know how to keep properties files clean, organized, and safer.

Understanding security and organization prevents leaks and confusion in team projects.

5

Advanced

Dynamic Properties Loading for Multiple Environments

🤔Before reading on: do you think one properties file is enough for all test environments? Commit to your answer.

Concept: Use multiple properties files to handle different environments like dev, test, and production.

Create separate files like dev.properties, test.properties, prod.properties. Load the right one based on a system property or environment variable: String env = System.getProperty("env", "dev"); Properties prop = new Properties(); try (FileInputStream fis = new FileInputStream(env + ".properties")) { prop.load(fis); } This lets you run tests against different environments without changing code.

Result

Tests automatically pick configuration for the chosen environment at runtime.

Knowing how to switch configs dynamically supports continuous integration and flexible testing.

6

Expert

Handling Properties File Pitfalls and Performance

🤔Before reading on: do you think loading properties files repeatedly in tests affects performance? Commit to your answer.

Concept: Understand common issues like repeated loading, missing keys, and how to optimize properties usage.

Loading properties files multiple times wastes resources. Cache the Properties object once per test run. Always check for missing keys to avoid NullPointerExceptions: String browser = prop.getProperty("browser"); if (browser == null) { throw new RuntimeException("Missing browser property"); } Use defaults or fail fast. Also, watch out for encoding issues; properties files should be ISO-8859-1 encoded or use Unicode escapes. These practices prevent flaky tests and improve reliability.

Result

Tests run faster and fail clearly if configuration is incomplete or wrong.

Understanding these pitfalls helps build robust, maintainable test frameworks.

Under the Hood

Properties files are loaded by Java's Properties class which reads the file line by line, parsing each line into a key and value separated by '=' or ':'. It stores these pairs in a hash table for fast lookup. When getProperty(key) is called, it returns the associated value or null if missing. The loading process uses InputStream to read bytes and converts them to characters using a default or specified encoding.

Why designed this way?

Properties files were designed as a simple, human-readable way to externalize configuration from Java programs. The key-value format is easy to parse and edit without special tools. This design avoids complex formats to keep configuration accessible to non-programmers. Alternatives like XML or JSON are more complex but offer richer structure; properties files remain popular for their simplicity and legacy support.

┌───────────────┐
│ Properties    │
│ File (text)   │
│ key=value     │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ FileInputStream│
│ Reads bytes   │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Properties    │
│ Class Parser  │
│ Splits lines  │
│ Stores pairs  │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ HashTable     │
│ Stores keys & │
│ values       │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do you think properties files can store complex nested data structures like JSON? Commit yes or no.

Common Belief: Properties files can store any kind of data including nested objects and arrays.

Reality: Properties files only store flat key-value pairs as strings. They do not support nested or complex data structures.

Why it matters: Trying to store complex data in properties files leads to messy workarounds and bugs. Use JSON or YAML for structured data instead.

Quick: Do you think properties files automatically reload if changed during test execution? Commit yes or no.

Common Belief: Once loaded, properties files update automatically if the file changes on disk.

Reality: Properties files are loaded once into memory. Changes on disk after loading do not affect the running program unless explicitly reloaded.

Why it matters: Assuming automatic reload can cause tests to use stale configuration, leading to confusion and errors.

Quick: Is it safe to store passwords in plain text properties files in public repositories? Commit yes or no.

Common Belief: Storing passwords in plain text properties files is fine if the repository is private.

Reality: Storing sensitive data in plain text is risky even in private repos. Secrets should be encrypted or managed with secure vaults.

Why it matters: Exposing credentials can lead to security breaches and unauthorized access.

Quick: Do you think missing keys in properties files return empty strings? Commit yes or no.

Common Belief: If a key is missing, getProperty returns an empty string, so tests won't fail.

Reality: getProperty returns null if the key is missing, which can cause NullPointerExceptions if not handled.

Why it matters: Not checking for null leads to runtime errors and flaky tests.

Expert Zone

1

Properties files do not support comments inside values; any '#' or '!' after the key is treated as comment, which can cause subtle bugs if included in values.

2

The default encoding for properties files is ISO-8859-1, so Unicode characters must be escaped, which can confuse beginners expecting UTF-8 support.

3

Caching the loaded Properties object and reusing it across tests improves performance and avoids repeated file I/O overhead.

When NOT to use

Properties files are not suitable when configuration requires complex nested data, arrays, or hierarchical structures. In such cases, use JSON, YAML, or XML configuration files. Also, for sensitive data, use secure vaults or environment variables instead of plain text properties files.

Production Patterns

In real-world Selenium frameworks, properties files are combined with environment variables and CI/CD pipeline parameters to manage configurations dynamically. Frameworks often implement a ConfigManager class that loads and caches properties, provides defaults, and validates keys to ensure robust test runs.

Connections

Environment Variables

complementary configuration methods

Knowing how properties files and environment variables work together helps build flexible test setups that adapt to different machines and pipelines.

Dependency Injection

builds-on configuration management

Understanding properties files prepares you to use dependency injection frameworks that inject configuration values into tests automatically, improving modularity.

Software Configuration Management (SCM)

shared principles of externalizing configuration

Recognizing that properties files are a form of SCM helps appreciate the broader practice of separating code from configuration in software engineering.

Common Pitfalls

#1 Hardcoding configuration values inside test code.

Wrong approach:

WebDriver driver = new ChromeDriver();
driver.get("https://example.com");

Correct approach:

Properties prop = new Properties();
try (FileInputStream fis = new FileInputStream("config.properties")) {
prop.load(fis);
}
String browser = prop.getProperty("browser");
if (browser.equalsIgnoreCase("chrome")) {
driver = new ChromeDriver();
}
driver.get(prop.getProperty("url"));

Root cause:

Beginners often put all values directly in code, not realizing this reduces flexibility and maintainability.

#2 Not handling missing keys leading to NullPointerException.

Wrong approach:

String url = prop.getProperty("url");
driver.get(url); // no null check

Correct approach:

String url = prop.getProperty("url");
if (url == null) {
throw new RuntimeException("Missing url property");
}
driver.get(url);

Root cause:

Assuming all keys exist without validation causes runtime crashes.

#3 Storing sensitive data like passwords in plain text properties files committed to public repos.

Wrong approach:

# config.properties
password=secret123

Correct approach:

# config.properties
password=${env.PASSWORD} # Use environment variable instead

Root cause:

Lack of awareness about security risks and best practices for secret management.

Key Takeaways

Properties files store configuration as simple key-value pairs outside test code, improving flexibility.

Java's Properties class loads these files so tests can read settings dynamically at runtime.

Using properties files in Selenium tests allows easy switching of browsers, URLs, and credentials without code changes.

Proper organization, security, and validation of properties files prevent common errors and security risks.

Advanced use includes multiple environment files and caching for performance, supporting robust real-world test frameworks.

Practice

1. What is the main purpose of using a .properties file in Selenium Java tests?

easy

A. To compile Java source files automatically

B. To write the test cases in a different programming language

C. To store configuration data like URLs and credentials outside the test code

D. To store screenshots taken during test execution

Solution

1. Step 1: Understand the role of properties files

   Properties files are used to keep configuration data separate from code, such as URLs, usernames, and passwords.

2. Step 2: Identify the correct purpose in Selenium tests

   Using properties files makes tests flexible and easier to maintain by avoiding hard-coded values.

3. Final Answer:

   To store configuration data like URLs and credentials outside the test code -> Option C

4. Quick Check:

   Properties file = external config storage [OK]

Hint: Properties files hold config, not code or screenshots [OK]

Common Mistakes:

• Thinking properties files contain test scripts
• Confusing properties files with logs or reports
• Assuming properties files compile code

2. Which Java class is commonly used to load a .properties file in Selenium tests?

easy

A. Properties

B. FileReader

C. BufferedReader

D. FileInputStream

Solution

1. Step 1: Identify the class for properties handling

   The Properties class in Java is designed to load and read key-value pairs from .properties files.

2. Step 2: Differentiate from other classes

   While FileReader and FileInputStream help read files, Properties specifically loads and manages properties data.

3. Final Answer:

   Properties -> Option A

4. Quick Check:

   Java Properties class loads config files [OK]

Hint: Use Properties class to load .properties files [OK]

Common Mistakes:

• Using FileReader alone without Properties
• Confusing BufferedReader with Properties
• Trying to load properties without Properties class

3. Given the following code snippet, what will be the output if the config.properties file contains url=https://example.com?

Properties prop = new Properties();
FileInputStream fis = new FileInputStream("config.properties");
prop.load(fis);
System.out.println(prop.getProperty("url"));

medium

A. null

B. https://example.com

C. url=https://example.com

D. FileNotFoundException

Solution

1. Step 1: Load properties from file

   The Properties object loads key-value pairs from the file using load().

2. Step 2: Retrieve the value for key 'url'

   Calling getProperty("url") returns the value associated with 'url', which is 'https://example.com'.

3. Final Answer:

   https://example.com -> Option B

4. Quick Check:

   getProperty('url') = 'https://example.com' [OK]

Hint: getProperty(key) returns the value for that key [OK]

Common Mistakes:

• Expecting the whole line instead of just the value
• Confusing key with value in output
• Not loading the file before getting property

4. Identify the error in the following code snippet that tries to load a properties file:

Properties prop = new Properties();
FileInputStream fis = new FileInputStream("config.properties");
prop.load();
System.out.println(prop.getProperty("browser"));

medium

A. Missing argument in prop.load() method

B. FileInputStream path is incorrect

C. Properties object not instantiated

D. getProperty method is misspelled

Solution

1. Step 1: Check method usage for loading properties

   The load() method requires an InputStream argument, but here it is called without any argument.

2. Step 2: Verify other parts of the code

   The FileInputStream is correctly created, Properties is instantiated, and getProperty is spelled correctly.

3. Final Answer:

   Missing argument in prop.load() method -> Option A

4. Quick Check:

   load() needs InputStream argument [OK]

Hint: Always pass InputStream to load() method [OK]

Common Mistakes:

• Calling load() without argument
• Assuming load() reads file automatically
• Ignoring exceptions from FileInputStream

5. You want to switch browsers in your Selenium tests by changing only the browser value in a config.properties file. Which approach correctly reads this value and uses it to launch Chrome or Firefox browsers?

hard

A. Use getProperty('browser') but always launch ChromeDriver regardless of value

B. Hardcode browser choice in test code and ignore properties file

C. Load properties but never read 'browser' key, just launch FirefoxDriver

D. Load properties, get 'browser' value, then use if-else to create ChromeDriver or FirefoxDriver accordingly

Solution

1. Step 1: Load the properties file and read the 'browser' key

   Use Properties class to load the file and get the value of 'browser' key.

2. Step 2: Use conditional logic to launch the correct browser driver

   If the value is 'chrome', create a ChromeDriver instance; if 'firefox', create a FirefoxDriver instance.

3. Final Answer:

   Load properties, get 'browser' value, then use if-else to create ChromeDriver or FirefoxDriver accordingly -> Option D

4. Quick Check:

   Config-driven browser choice = if-else on getProperty('browser') [OK]

Hint: Use if-else on property value to pick browser driver [OK]

Common Mistakes:

• Ignoring properties file and hardcoding browser
• Not using conditional logic for browser selection
• Loading properties but not reading the key