Testing Fundamentals

🧪 Testing Fundamentals in Spring Boot

The Story of the Safety Net

Imagine you’re a tightrope walker. Would you walk across a rope 100 feet in the air without a safety net? Of course not!

Testing is your safety net for code. It catches you when you fall. It gives you confidence to walk that tightrope boldly.

In Spring Boot, testing is like having a magical safety net that:

• Catches bugs before users see them
• Lets you change code without fear
• Proves your code actually works

🎯 The Three Heroes of Spring Boot Testing

Think of testing like a superhero team. Each hero has a special power:

Let’s meet each hero!

🚀 Hero #1: @SpringBootTest

What Is It?

@SpringBootTest is like turning on your ENTIRE house to check if the lights work.

It starts up your whole Spring application. Every piece. Every connection. Everything.

Simple Example

@SpringBootTest
class MyAppTests {

    @Autowired
    private UserService userService;

    @Test
    void userServiceWorks() {
        // Your whole app is running!
        User user = userService.findById(1L);
        assertNotNull(user);
    }
}

What Happens When You Use It?

graph TD
    A["Test Starts"] --> B["Spring Boots Up"]
    B --> C["All Beans Created"]
    C --> D["Database Connected"]
    D --> E["Your Test Runs"]
    E --> F["Everything Shuts Down"]

When to Use @SpringBootTest

✅ Use it when:

• Testing how pieces work TOGETHER
• Testing real database connections
• Testing full API flows

❌ Don’t use it when:

• You just want to test ONE small thing
• Speed matters (it’s slower)
• You need many quick tests

Real World Analogy

@SpringBootTest = Inviting the WHOLE family for dinner to see if everyone gets along.

Sometimes you need everyone there. But it takes time to cook for 20 people!

⚡ Hero #2: Test Slices

The Problem with Testing Everything

Imagine checking if your car radio works by:

1. Starting the engine
2. Checking all tires
3. Testing windshield wipers
4. THEN checking the radio

That’s silly! Just check the radio!

Test Slices let you test just ONE slice of your application.

The Slice Family

@WebMvcTest Example

Test ONLY your web layer. Nothing else.

@WebMvcTest(UserController.class)
class UserControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private UserService userService;

    @Test
    void getUser_ReturnsUser() throws Exception {
        // Mock the service
        when(userService.findById(1L))
            .thenReturn(new User("Alice"));

        // Test the controller
        mockMvc.perform(get("/users/1"))
            .andExpect(status().isOk())
            .andExpect(jsonPath("$.name")
                .value("Alice"));
    }
}

@DataJpaTest Example

Test ONLY your database layer.

@DataJpaTest
class UserRepositoryTest {

    @Autowired
    private UserRepository userRepository;

    @Test
    void saveUser_Works() {
        User user = new User("Bob");
        User saved = userRepository.save(user);

        assertNotNull(saved.getId());
        assertEquals("Bob", saved.getName());
    }
}

Why Slices Are Faster

graph TD
    A["Full Test"] --> B["Loads EVERYTHING"]
    B --> C["Takes 10+ seconds"]

    D["Slice Test"] --> E["Loads ONE piece"]
    E --> F["Takes 1-2 seconds"]

Slice Comparison

⚙️ Hero #3: Test Configuration

What Is Test Configuration?

Sometimes tests need a DIFFERENT setup than your real app.

Test Configuration = Creating a special test world

Real Life Example

Your app uses a REAL database. But tests should use a FAKE one.

Why?

• Real databases are slow
• Tests might break real data
• Tests should be repeatable

Using @TestConfiguration

@TestConfiguration
class TestDatabaseConfig {

    @Bean
    public DataSource dataSource() {
        // Use H2 in-memory database
        return new EmbeddedDatabaseBuilder()
            .setType(EmbeddedDatabaseType.H2)
            .build();
    }
}

Importing Test Configuration

@SpringBootTest
@Import(TestDatabaseConfig.class)
class MyAppTests {
    // Uses the test database!
}

Common Test Configuration Patterns

1. Test Properties

@SpringBootTest
@TestPropertySource(properties = {
    "spring.mail.host=localhost",
    "app.feature.enabled=false"
})
class MyTests {
    // Uses test properties
}

2. Active Profiles

@SpringBootTest
@ActiveProfiles("test")
class MyTests {
    // Uses application-test.properties
}

3. Mock Beans

@SpringBootTest
class MyTests {

    @MockBean
    private EmailService emailService;

    // EmailService is now a mock!
}

Configuration Flow

graph TD
    A["Test Starts"] --> B{Check Configs}
    B --> C["@TestConfiguration"]
    B --> D["@TestPropertySource"]
    B --> E["@ActiveProfiles"]
    C --> F["Custom Beans"]
    D --> G["Custom Properties"]
    E --> H["Profile Settings"]
    F --> I["Test Runs"]
    G --> I
    H --> I

🎯 Putting It All Together

Decision Guide

graph TD
    A["What do you want to test?"] --> B{Full integration?}
    B -->|Yes| C["@SpringBootTest"]
    B -->|No| D{Which layer?}
    D -->|Web| E["@WebMvcTest"]
    D -->|Database| F["@DataJpaTest"]
    D -->|JSON| G["@JsonTest"]
    C --> H{Need custom setup?}
    E --> H
    F --> H
    G --> H
    H -->|Yes| I["Add @TestConfiguration"]
    H -->|No| J["Ready to test!"]
    I --> J

Complete Example

Here’s a full test class using all three heroes:

@SpringBootTest
@ActiveProfiles("test")
@Import(TestSecurityConfig.class)
class UserIntegrationTest {

    @Autowired
    private UserService userService;

    @MockBean
    private EmailService emailService;

    @Test
    void createUser_SendsWelcomeEmail() {
        // Arrange
        User newUser = new User("Charlie");

        // Act
        userService.create(newUser);

        // Assert
        verify(emailService)
            .sendWelcome("Charlie");
    }
}

🌟 Key Takeaways

1. @SpringBootTest = Test everything together. Slow but thorough.

2. Test Slices = Test one layer. Fast and focused.

3. Test Configuration = Customize your test world.

Memory Trick

Think of testing like cooking:

• @SpringBootTest = Full dinner party (everything)
• Test Slices = Taste-test one dish (focused)
• Test Configuration = Your recipe adjustments (customization)

🚀 You’re Ready!

You now understand the three pillars of Spring Boot testing:

Go forth and test with confidence!

Your code now has a safety net. Bugs can’t hide. Your app is reliable.

That’s the power of testing. 🎯