Test profiles and configuration in Spring Boot - Step-by-Step Execution

Concept Flow - Test profiles and configuration

Start Application

↓

Check Active Profile

↓

Load application-{profile}.properties

↓

Override default config

↓

Run Tests with Profile

↓

Use Profile-specific Beans

↓

Tests Execute with Configured Settings

↓

End

The application starts, checks which profile is active, loads the matching configuration, overrides defaults, and runs tests using those settings.

Execution Sample

Spring Boot

@SpringBootTest
@ActiveProfiles("test")
class MyServiceTest {
  @Autowired
  MyService service;
  @Test
  void testMethod() {
    assertEquals("testValue", service.getConfigValue());
  }
}

This test runs with the 'test' profile active, so it uses test-specific configuration values.

Execution Table

Step	Action	Profile Active	Config Loaded	Bean Used	Test Output
1	Start Application	none	application.properties	default beans	N/A
2	Activate 'test' profile	test	application-test.properties	test beans if any	N/A
3	Load Configurations	test	Defaults overridden by test config	test beans	N/A
4	Run testMethod()	test	application-test.properties	test beans	service.getConfigValue() returns 'testValue'
5	Assert result	test	application-test.properties	test beans	Pass: 'testValue' matches expected
6	End Test	test	application-test.properties	test beans	Test completes successfully

💡 Test finishes after asserting the expected value with the test profile configuration.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
activeProfile	none	test	test	test	test
configSource	application.properties	application-test.properties	application-test.properties	application-test.properties	application-test.properties
beanType	default	test	test	test	test
service.getConfigValue()	N/A	N/A	N/A	testValue	testValue

Key Moments - 2 Insights

Why does the test use 'application-test.properties' instead of 'application.properties'?

Because the '@ActiveProfiles("test")' annotation activates the 'test' profile, causing Spring Boot to load 'application-test.properties' which overrides the default config as shown in execution_table step 2 and 3.

How does Spring Boot know which beans to use for the test profile?

Spring Boot loads beans annotated or configured for the active profile. In the execution_table steps 3 and 4, 'test beans' are used instead of default beans because the 'test' profile is active.

Visual Quiz - 3 Questions

Look at the execution_table at step 4, what value does 'service.getConfigValue()' return?

A "null"

B "testValue"

C "defaultValue"

D "productionValue"

💡 Hint

Check the 'Test Output' column at step 4 in the execution_table.

At which step does the application load the profile-specific configuration?

A Step 3

B Step 1

C Step 2

D Step 5

💡 Hint

Look at the 'Config Loaded' column in the execution_table to find when overrides happen.

If the '@ActiveProfiles' annotation was removed, what would change in the variable_tracker?

A beanType would be 'test'

B activeProfile would remain 'test'

C configSource would be 'application.properties'

D service.getConfigValue() would return 'testValue'

💡 Hint

Refer to the 'activeProfile' and 'configSource' rows in variable_tracker to see what changes without profile activation.

Concept Snapshot

Test Profiles and Configuration in Spring Boot:
- Use @ActiveProfiles("profileName") to activate a profile in tests.
- Spring Boot loads application-{profile}.properties overriding defaults.
- Beans and configs change based on active profile.
- Tests run with profile-specific settings for isolation.
- Helps separate dev, test, prod configs cleanly.

Full Transcript

In Spring Boot, test profiles let you run tests with special settings. When the application starts, it checks which profile is active. If the 'test' profile is active, it loads 'application-test.properties' to override default settings. Beans specific to the test profile are used. This way, tests run with configurations made just for testing. The example code shows a test class with '@ActiveProfiles("test")' which activates the test profile. The execution table traces how the profile activates, config files load, beans switch, and the test method returns the expected test value. Variables like activeProfile and configSource change to reflect the test profile. This helps keep test settings separate from production or development. Understanding when and how profiles load helps avoid confusion about which configs and beans are used during tests.

Practice

1. What is the main purpose of using test profiles in a Spring Boot application?

easy

A. To run the application with special settings only during testing

B. To improve the application's runtime performance in production

C. To automatically generate test data for the application

D. To disable security features permanently

Solution

1. Step 1: Understand test profiles concept

   Test profiles allow running the app with different settings specifically for testing purposes.

2. Step 2: Compare options

   Only To run the application with special settings only during testing correctly describes the purpose of test profiles as special settings for tests.

3. Final Answer:

   To run the application with special settings only during testing -> Option A

4. Quick Check:

   Test profiles = special test settings [OK]

Hint: Test profiles isolate test settings from production [OK]

Common Mistakes:

• Confusing test profiles with performance tuning
• Thinking test profiles generate test data automatically
• Assuming test profiles disable security permanently

2. Which of the following is the correct way to name a properties file for a test profile named testdb?

easy

A. application.properties.testdb

B. testdb-application.properties

C. application-testdb.properties

D. application_testdb.properties

Solution

1. Step 1: Recall Spring Boot profile file naming

   Spring Boot uses the pattern application-{profile}.properties for profile-specific config files.

2. Step 2: Match the pattern with the profile name

   For profile testdb, the correct file name is application-testdb.properties.

3. Final Answer:

   application-testdb.properties -> Option C

4. Quick Check:

   Profile file = application-{profile}.properties [OK]

Hint: Use application-{profile}.properties naming [OK]

Common Mistakes:

• Placing profile name after .properties
• Using underscores instead of hyphens
• Reversing the order of profile and application

3. Given the following test class annotation:
@ActiveProfiles("test")
and two property files:
application.properties with db.url=prod-db
application-test.properties with db.url=test-db
What will be the value of db.url during this test?

medium

A. prod-db

B. test-db

C. null

D. application.properties

Solution

1. Step 1: Understand @ActiveProfiles effect

   @ActiveProfiles("test") activates the 'test' profile for the test run.

2. Step 2: Determine property file precedence

   Properties in application-test.properties override those in application.properties when 'test' profile is active.

3. Final Answer:

   test-db -> Option B

4. Quick Check:

   Active profile properties override default [OK]

Hint: Active profile properties override defaults [OK]

Common Mistakes:

• Assuming default properties always apply
• Confusing profile name in annotation
• Expecting null if profile is active

4. You have a test annotated with @ActiveProfiles("dev") but the test still uses properties from application.properties instead of application-dev.properties. What is the most likely cause?

medium

A. The test class must extend a special base class to use profiles

B. The @ActiveProfiles annotation is only for production

C. Spring Boot does not support multiple profiles

D. The application-dev.properties file is missing or misnamed

Solution

1. Step 1: Check profile file presence

   If application-dev.properties is missing or named incorrectly, Spring Boot falls back to application.properties.

2. Step 2: Verify annotation usage

   @ActiveProfiles works for tests to activate profiles; it is not limited to production.

3. Final Answer:

   The application-dev.properties file is missing or misnamed -> Option D

4. Quick Check:

   Missing profile file causes fallback to default [OK]

Hint: Check profile file name and location first [OK]

Common Mistakes:

• Thinking @ActiveProfiles is ignored in tests
• Believing Spring Boot lacks profile support
• Assuming inheritance is required for profiles

5. You want to run integration tests with a profile integration that uses a different database URL and disables security. Which combination correctly activates this profile and overrides the default settings?

hard

A. Create application-integration.properties with overrides and annotate tests with @ActiveProfiles("integration")

B. Add spring.profiles.active=integration only in application.properties

C. Use @Profile("integration") on the test class without any properties file

D. Set environment variable SPRING_PROFILE=integration but keep default properties unchanged

Solution

1. Step 1: Use profile-specific properties file

   Create application-integration.properties to override database URL and security settings for the integration profile.

2. Step 2: Activate profile in tests

   Annotate tests with @ActiveProfiles("integration") to activate the profile during test runs.

3. Final Answer:

   Create application-integration.properties with overrides and annotate tests with @ActiveProfiles("integration") -> Option A

4. Quick Check:

   Profile file + @ActiveProfiles activates test config [OK]

Hint: Use profile file plus @ActiveProfiles to activate [OK]

Common Mistakes:

• Setting active profile only in default properties
• Using @Profile instead of @ActiveProfiles on tests
• Relying on environment variable without config changes