Repository & Service Testing

Testing is a core practice for building reliable, scalable, and production-ready Spring Boot applications. In Spring Boot, repository and service testing ensures that both your data access layer and business logic work correctly, independently, and reliably.

What Is Repository Testing?

Repository Testing verifies the data access layer. It focuses on checking that JPA repositories, CRUD operations, custom queries, and entity relationships work correctly.

Repository testing ensures:

• JPA queries return correct results
• CRUD operations behave as expected
• Entity mappings and database constraints are valid
• Tests are fast and isolated (using in-memory databases like H2)

Key Annotation: @DataJpaTest

@DataJpaTest is designed for repository testing in Spring Boot.

Features of @DataJpaTest:

• Loads only JPA-related components (repositories, entities)
• Configures an in-memory database (H2 by default)
• Rolls back transactions after each test
• Excludes services and controllers for lightweight tests

@DataJpaTest
class UserRepositoryTest {
    // Repository tests go here
}

Repository Test Example

Entity:

The User entity defines the database table structure with fields like id, name, and email. Entities are used by JPA repositories to perform CRUD operations.

import jakarta.persistence.*;

@Entity
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private String email;

    // Constructors
    public User() {}
    public User(Long id, String name, String email) {
        this.id = id;
        this.name = name;
        this.email = email;
    }

    // Getters and Setters
    public Long getId() { return id; }
    public String getName() { return name; }
    public String getEmail() { return email; }
}

Repository:

The UserRepository interface extends JpaRepository and provides methods to query the database, such as findByEmail. Custom queries can also be added using @Query.

import org.springframework.data.jpa.repository.JpaRepository;
import java.util.Optional;

public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByEmail(String email);
}

Test Class: UserRepositoryTest:

The UserRepositoryTest class shows how to test repository methods using @DataJpaTest.

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;

import java.util.Optional;

import static org.junit.jupiter.api.Assertions.*;

@DataJpaTest
class UserRepositoryTest {

    @Autowired
    private UserRepository userRepository;

    @Test
    void shouldFindUserByEmail() {
        // Arrange: create and save a new user
        User user = new User(null, "Alice", "[email protected]");
        userRepository.save(user);

        // Act: retrieve the user by email
        Optional<User> result = userRepository.findByEmail("[email protected]");

        // Assert: verify the user exists and has correct details
        assertTrue(result.isPresent());
        assertEquals("Alice", result.get().getName());
    }

    @Test
    void shouldReturnEmptyIfUserNotFound() {
        // Act: search for a non-existent user
        Optional<User> result = userRepository.findByEmail("[email protected]");

        // Assert: verify that no user is found
        assertFalse(result.isPresent());
    }
}

When to Use @DataJpaTest

• CRUD operations
• Custom JPQL or SQL queries
• Entity mappings and relationships
• Database constraints

Repository testing is fast, reliable, and focuses purely on the database layer.

What Is Service Testing?

Service Testing validates the business logic layer.

It ensures that:

• Business rules are applied correctly
• Services interact properly with repositories
• Edge cases and exceptions are handled
• Logic works independently of the database

Service testing often mocks dependencies to isolate logic and make tests fast.

Key Annotations for Service Testing

• @ExtendWith(MockitoExtension.class) – For unit testing services without Spring context
• @Mock – For mocking repository dependencies
• @InjectMocks – Inject mocks into the service under test
• @MockBean – For integration tests with Spring context

Service Test Example Using Mockito

Sample Service Class: UserService

A simple service interacting with the repository:

import org.springframework.stereotype.Service;

@Service
publicclassUserService {

privatefinal UserRepository userRepository;

publicUserService(UserRepository userRepository) {
this.userRepository = userRepository;
    }

// Fetch a user by ID
public UsergetUserById(Long id) {
return userRepository.findById(id)
            .orElseThrow(() ->newRuntimeException("User not found"));
    }

// Create a new user
public UsercreateUser(User user) {
return userRepository.save(user);
    }
}

Key Points:

• Contains business logic
• Interacts with the repository
• Methods can be unit-tested independently of the database

Service Unit Testing with Mockito

Unit tests isolate the service logic by mocking dependencies. No database is required, so tests are fast and reliable.

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension;

import java.util.Optional;

importstatic org.junit.jupiter.api.Assertions.*;

@ExtendWith(MockitoExtension.class)
classUserServiceTest {

@Mock
private UserRepository userRepository;

@InjectMocks
private UserService userService;

@Test
voidtestGetUserById() {
// Arrange
Useruser=newUser(1L,"Alice","[email protected]");
        Mockito.when(userRepository.findById(1L)).thenReturn(Optional.of(user));

// Act
Userresult= userService.getUserById(1L);

// Assert
        assertEquals("Alice", result.getName());
    }

@Test
voidtestCreateUser() {
// Arrange
Useruser=newUser(null,"Bob","[email protected]");
        Mockito.when(userRepository.save(user)).thenReturn(newUser(1L,"Bob","[email protected]"));

// Act
Userresult= userService.createUser(user);

// Assert
        assertNotNull(result.getId());
        assertEquals("Bob", result.getName());
    }
}

Benefits of Mockito for Service Testing:

• No database required
• No Spring context loading
• Very fast execution
• Pure business logic validation

Service Integration Testing

Sometimes, services need to be tested together with real repositories and database interactions. For this, use @SpringBootTest.

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

importstatic org.junit.jupiter.api.Assertions.*;

@SpringBootTest
classUserServiceIntegrationTest {

@Autowired
private UserService userService;

@Autowired
private UserRepository userRepository;

@Test
voidtestCreateAndRetrieveUser() {
// Arrange
Useruser=newUser(null,"Charlie","[email protected]");
        userService.createUser(user);

// Act
Userretrieved= userService.getUserById(user.getId());

// Assert
        assertEquals("Charlie", retrieved.getName());
    }
}

• Loads full application context
• Tests service + repository together
• Useful for end-to-end validation

Difference Between Repository vs Service Testing

Best Practices

• Keep repository tests focused on CRUD and queries
• Keep service tests focused on business rules
• Use Mockito or @MockBean to isolate dependencies
• Rollback DB changes after tests to maintain clean state
• Combine unit and integration tests for full coverage
• Separate repository, service, and controller tests for clarity
• Avoid loading full Spring context unnecessarily

Why Repository & Service Testing Matters

Repository and service tests help you:

• Catch bugs early – Test logic before deployment
• Validate database operations – Ensure JPA queries and entities work
• Isolate layers – Services can be tested without the database, repositories without services
• Improve code quality – Enforce better separation of concerns
• Faster feedback loop – Unit and repository tests run quickly using mocks or in-memory DBs

Key Takeaways

• Repository testing validates the data layer with @DataJpaTest
• Service testing validates business logic using Mockito or JUnit
• Integration tests (@SpringBootTest) combine repository + service testing
• Use in-memory DBs for speed, real DBs for accuracy
• Maintain isolated, fast, and reliable tests for production-ready Spring Boot applications

Conclusion

Repository and service testing are essential for building robust Spring Boot applications. By following these guidelines:

• Use @DataJpaTest for repository tests
• Use Mockito / @ExtendWith for service unit tests
• Use @SpringBootTest for full integration tests

you ensure that your data layer works correctly, business rules are enforced, and your application remains bug-free.