Spring Boot'ta test yazma konusunda size yardımcı olabilirim. Spring Boot, test yazımını kolaylaştıran birçok özellik ve araç sunar. İşte Spring Boot'ta test yazmanın temel adımları:
- Test bağımlılıklarını ekleyin: Spring Boot projenizde, pom.xml (Maven) veya build.gradle (Gradle) dosyanızda test bağımlılıklarının olduğundan emin olun. Genellikle spring-boot-starter-test bu iş için yeterlidir.
- Test sınıfını oluşturun: Test edeceğiniz sınıf veya bileşen için bir test sınıfı oluşturun. Genellikle test sınıfları, test edilen sınıfın adının sonuna "Test" eklenerek adlandırılır.
- Gerekli annotasyonları ekleyin: Test sınıfınıza @SpringBootTest annotasyonunu ekleyin. Bu, Spring Boot uygulamanızın test ortamında başlatılmasını sağlar.
- Test metodlarını yazın: @Test annotasyonu ile işaretlenmiş test metodları yazın. Her test metodu belirli bir işlevselliği veya senaryoyu test etmelidir.
İşte basit bir örnek:
javaimport org.junit.jupiter.api.Test; import org.springframework.boot.test.context.SpringBootTest; import static org.junit.jupiter.api.Assertions.*; @SpringBootTest public class MyServiceTest { @Autowired private MyService myService; @Test public void testSomeFunction() { String result = myService.someFunction(); assertEquals("expected result", result); } }
Bu örnek, temel bir Spring Boot testi göstermektedir.
Mockito kullanarak Spring Boot testleri yazmak, bağımlılıkları taklit etmek ve davranışlarını kontrol etmek için harika bir yoldur. İşte Mockito ile Spring Boot testleri yazmanın temel adımları:
- Bağımlılıkları ekleyin: Spring Boot Starter Test, Mockito'yu içerir, bu nedenle ek bir bağımlılık eklemeniz gerekmez.
- Test sınıfını hazırlayın: @SpringBootTest yerine @ExtendWith(MockitoExtension.class) kullanın. Bu, Mockito'nun JUnit 5 ile entegrasyonunu sağlar.
- Mocklanacak bağımlılıkları tanımlayın: @Mock annotasyonu ile mock nesneleri oluşturun.
- Test edilecek sınıfı enjekte edin: @InjectMocks annotasyonu ile test edilecek sınıfı oluşturun ve mock'ları otomatik olarak enjekte edin.
- Test metodlarını yazın: Mockito metodlarını kullanarak mock nesnelerin davranışlarını tanımlayın ve test senaryolarınızı oluşturun.
İşte bir örnek:
javaimport org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; import static org.mockito.Mockito.*; import static org.junit.jupiter.api.Assertions.*; @ExtendWith(MockitoExtension.class) public class UserServiceTest { @Mock private UserRepository userRepository; @InjectMocks private UserService userService; @Test public void testGetUserById() { // Arrange Long userId = 1L; User mockUser = new User(userId, "John Doe"); when(userRepository.findById(userId)).thenReturn(Optional.of(mockUser)); // Act User result = userService.getUserById(userId); // Assert assertNotNull(result); assertEquals(userId, result.getId()); assertEquals("John Doe", result.getName()); verify(userRepository, times(1)).findById(userId); } @Test public void testGetUserByIdNotFound() { // Arrange Long userId = 1L; when(userRepository.findById(userId)).thenReturn(Optional.empty()); // Act & Assert assertThrows(UserNotFoundException.class, () -> { userService.getUserById(userId); }); verify(userRepository, times(1)).findById(userId); } }
Bu örnekte:
- @Mock ile userRepository'yi mockluyoruz.
- @InjectMocks ile userService'i oluşturup, mocklanan repository'yi enjekte ediyoruz.
- when().thenReturn() ile mock davranışını tanımlıyoruz.
- verify() ile mock metodunun çağrılıp çağrılmadığını kontrol ediyoruz.
Mockito'nun sağladığı bazı temel metodlar:
- when().thenReturn(): Mock nesnenin belirli bir metod çağrısına ne döndüreceğini belirtir.
- verify(): Bir metodun çağrılıp çağrılmadığını ve kaç kez çağrıldığını kontrol eder.
- any(), anyInt(), anyString(): Argüman eşleştiriciler olarak kullanılır.
- doThrow(): Bir metodun istisna fırlatmasını sağlar.
Mockito ile Spring context'in ayağa kaldırıldığı testler yazmak mümkündür. Bu tür testler, gerçek Spring bileşenlerini kullanırken bazı bağımlılıkları mock'lamanıza olanak tanır. İşte bu tür bir test yazmanın adımları ve bir örnek:
- Test sınıfını hazırlayın: @SpringBootTest annotasyonunu kullanın. Bu, tam Spring context'i yükler.
- MockBean kullanın: @MockBean annotasyonu ile mock'lanacak bağımlılıkları tanımlayın. Bu, Spring context'teki gerçek bean'lerin yerine mock'ları koyar.
- Gerçek bileşenleri enjekte edin: @Autowired annotasyonu ile test edilecek gerçek bileşenleri enjekte edin.
- Test metodlarını yazın: Mockito metodlarını kullanarak mock nesnelerin davranışlarını tanımlayın ve test senaryolarınızı oluşturun.
İşte bir örnek:
javaimport org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.boot.test.mock.mockito.MockBean; import static org.mockito.Mockito.*; import static org.junit.jupiter.api.Assertions.*; @SpringBootTest public class UserServiceIntegrationTest { @MockBean private UserRepository userRepository; @Autowired private UserService userService; @Test public void testGetUserById() { // Arrange Long userId = 1L; User mockUser = new User(userId, "John Doe"); when(userRepository.findById(userId)).thenReturn(Optional.of(mockUser)); // Act User result = userService.getUserById(userId); // Assert assertNotNull(result); assertEquals(userId, result.getId()); assertEquals("John Doe", result.getName()); verify(userRepository, times(1)).findById(userId); } @Test public void testCreateUser() { // Arrange User newUser = new User(null, "Jane Doe"); User savedUser = new User(1L, "Jane Doe"); when(userRepository.save(any(User.class))).thenReturn(savedUser); // Act User result = userService.createUser(newUser); // Assert assertNotNull(result); assertEquals(1L, result.getId()); assertEquals("Jane Doe", result.getName()); verify(userRepository, times(1)).save(any(User.class)); } }
Bu örnekte:
- @SpringBootTest ile tam Spring context'i yüklüyoruz.
- @MockBean ile userRepository'yi mockluyoruz. Bu, Spring context'teki gerçek UserRepository bean'ini mocklanmış versiyonu ile değiştirir.
- @Autowired ile gerçek UserService bean'ini enjekte ediyoruz.
- Test metodlarında, gerçek UserService'i kullanırken, UserRepository'nin davranışını mock'luyoruz.
Bu yaklaşımın avantajları:
- Gerçek Spring context'i kullanarak, bileşenler arasındaki gerçek entegrasyonu test edebilirsiniz.
- @MockBean kullanarak, dış sistemlere bağımlı olan veya test etmesi zor olan bileşenleri kolayca mock'layabilirsiniz.
- Spring'in dependency injection mekanizmasını kullanarak, gerçek ve mock bileşenleri bir arada kullanabilirsiniz.
Dezavantajı ise, tam Spring context'in yüklenmesi nedeniyle testlerin çalışma süresinin daha uzun olmasıdır.
Entegrasyon testleri, bir uygulamanın farklı bileşenlerinin birlikte doğru çalışıp çalışmadığını kontrol etmek için kullanılır. Spring Boot'ta entegrasyon testleri yazmak için birkaç yaklaşım vardır. İşte Spring Boot ile entegrasyon testleri yazmanın temel adımları ve yaklaşımları:
- Test sınıfını hazırlayın: @SpringBootTest annotasyonunu kullanın. Bu, tam uygulama bağlamını yükler.
- Gerekli bağımlılıkları enjekte edin: @Autowired annotasyonu ile test edilecek servisleri ve diğer bileşenleri enjekte edin.
- Test veritabanı yapılandırın (gerekirse): Test veritabanı olarak H2 gibi bir in-memory veritabanı kullanabilirsiniz.
- Test metodlarını yazın: @Test annotasyonu ile işaretlenmiş test metodları yazın.
İşte bir entegrasyon testi örneği:
javaimport org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.boot.test.web.client.TestRestTemplate; import org.springframework.boot.web.server.LocalServerPort; import org.springframework.http.HttpStatus; import org.springframework.http.ResponseEntity; import static org.assertj.core.api.Assertions.assertThat; @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT) public class UserControllerIntegrationTest { @LocalServerPort private int port; @Autowired private TestRestTemplate restTemplate; @Autowired private UserRepository userRepository; @Test public void testCreateUser() { // Arrange User newUser = new User(null, "John Doe"); // Act ResponseEntity<User> response = restTemplate.postForEntity("/api/users", newUser, User.class); // Assert assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CREATED); assertThat(response.getBody()).isNotNull(); assertThat(response.getBody().getId()).isNotNull(); assertThat(response.getBody().getName()).isEqualTo("John Doe"); // Verify the user was actually saved in the database User savedUser = userRepository.findById(response.getBody().getId()).orElse(null); assertThat(savedUser).isNotNull(); assertThat(savedUser.getName()).isEqualTo("John Doe"); } @Test public void testGetUserById() { // Arrange User user = userRepository.save(new User(null, "Jane Doe")); // Act ResponseEntity<User> response = restTemplate.getForEntity("/api/users/" + user.getId(), User.class); // Assert assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK); assertThat(response.getBody()).isNotNull(); assertThat(response.getBody().getId()).isEqualTo(user.getId()); assertThat(response.getBody().getName()).isEqualTo("Jane Doe"); } }
Bu örnekte:
- @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT) ile uygulamayı rastgele bir port üzerinde başlatıyoruz.
- TestRestTemplate kullanarak HTTP istekleri gönderiyoruz.
- UserRepository'yi kullanarak veritabanı durumunu doğruluyoruz.
Entegrasyon testleri için diğer önemli noktalar:
- Test veritabanı yönetimi: @SQL annotasyonu ile test öncesi ve sonrası veritabanı durumunu yönetebilirsiniz.
- Test profilleri: @ActiveProfiles annotasyonu ile test-spesifik profilleri etkinleştirebilirsiniz.
- MockMvc kullanımı: @AutoConfigureMockMvc annotasyonu ile MockMvc kullanarak HTTP isteklerini simüle edebilirsiniz.
- Taşınabilir veritabanları: Testler için Testcontainers gibi kütüphaneler kullanarak gerçek veritabanlarını Docker konteynerlerinde çalıştırabilirsiniz.
Örnek bir MockMvc kullanımı:
java@SpringBootTest @AutoConfigureMockMvc public class UserControllerMockMvcTest { @Autowired private MockMvc mockMvc; @Autowired private ObjectMapper objectMapper; @Test public void testCreateUser() throws Exception { User newUser = new User(null, "John Doe"); mockMvc.perform(post("/api/users") .contentType(MediaType.APPLICATION_JSON) .content(objectMapper.writeValueAsString(newUser))) .andExpect(status().isCreated()) .andExpect(jsonPath("$.id").exists()) .andExpect(jsonPath("$.name").value("John Doe")); } }
Entegrasyon testleri, uygulamanızın farklı katmanlarının ve bileşenlerinin birlikte doğru çalıştığını doğrulamak için önemlidir.
@SQL annotasyonu, Spring Boot testlerinde veritabanı durumunu yönetmek için kullanışlı bir araçtır. Bu annotasyon, test metodları çalışmadan önce veya sonra SQL komutlarını çalıştırmanıza olanak tanır. İşte @SQL annotasyonunun nasıl kullanılacağına dair detaylı bir açıklama ve örnekler:
- @SQL Annotasyonunun Kullanımı:
@SQL annotasyonu şu şekillerde kullanılabilir:
- Sınıf seviyesinde: Tüm test metodlarından önce çalıştırılır.
- Metod seviyesinde: Belirli bir test metodundan önce çalıştırılır.
- SQL dosyalarını referans göstererek
- Doğrudan SQL ifadelerini yazarak
- Örnek Kullanımlar:
a) SQL dosyasını referans gösterme:
java@SpringBootTest @Sql("/test-data.sql") public class UserServiceIntegrationTest { // Test metodları }
b) Doğrudan SQL ifadesi yazma:
java@SpringBootTest public class UserServiceIntegrationTest { @Test @Sql(statements = "INSERT INTO users (name, email) VALUES ('John Doe', 'john@example.com')") public void testGetUserByEmail() { // Test kodu } }
c) Birden fazla SQL dosyası veya ifadesi kullanma:
java@SpringBootTest @Sql(scripts = {"/schema.sql", "/test-data.sql"}) public class UserServiceIntegrationTest { // Test metodları }
d) Test öncesi ve sonrası için farklı SQL'ler kullanma:
java@SpringBootTest @Sql(scripts = "/test-data.sql", executionPhase = Sql.ExecutionPhase.BEFORE_TEST_METHOD) @Sql(scripts = "/cleanup.sql", executionPhase = Sql.ExecutionPhase.AFTER_TEST_METHOD) public class UserServiceIntegrationTest { // Test metodları }
- Pratik Bir Örnek:
java@SpringBootTest @Sql("/schema.sql") // Veritabanı şemasını oluştur public class UserServiceIntegrationTest { @Autowired private UserService userService; @Test @Sql(statements = { "INSERT INTO users (id, name, email) VALUES (1, 'John Doe', 'john@example.com')", "INSERT INTO users (id, name, email) VALUES (2, 'Jane Doe', 'jane@example.com')" }) public void testGetAllUsers() { List<User> users = userService.getAllUsers(); assertEquals(2, users.size()); assertEquals("John Doe", users.get(0).getName()); assertEquals("Jane Doe", users.get(1).getName()); } @Test @Sql(statements = "INSERT INTO users (id, name, email) VALUES (1, 'John Doe', 'john@example.com')") @Sql(statements = "DELETE FROM users", executionPhase = Sql.ExecutionPhase.AFTER_TEST_METHOD) public void testGetUserById() { User user = userService.getUserById(1L); assertNotNull(user); assertEquals("John Doe", user.getName()); } }
Bu örnekte:
- Sınıf seviyesinde
/schema.sqldosyası çalıştırılarak veritabanı şeması oluşturuluyor. testGetAllUsersmetodunda, test öncesi iki kullanıcı ekleniyor.testGetUserByIdmetodunda, test öncesi bir kullanıcı ekleniyor ve test sonrası tüm kullanıcılar siliniyor.
@SQL annotasyonu, test veritabanınızı istediğiniz duruma getirmenize ve her testin temiz bir ortamda çalışmasını sağlamanıza yardımcı olur. Bu, testlerinizin tutarlı ve güvenilir olmasını sağlar.
@ActiveProfiles annotasyonu, Spring Boot testlerinde belirli profilleri etkinleştirmek için kullanılır. Bu, test ortamınızı gerçek uygulamanızdan farklı şekilde yapılandırmanıza olanak tanır. İşte @ActiveProfiles'in kullanımı ve örnekler:
- @ActiveProfiles Annotasyonunun Kullanımı:
@ActiveProfiles annotasyonu genellikle test sınıfı seviyesinde kullanılır. Birden fazla profil etkinleştirilebilir.
java@SpringBootTest @ActiveProfiles("test") public class MyIntegrationTest { // Test metodları }
- Örnek Kullanımlar:
a) Tek bir profil etkinleştirme:
java@SpringBootTest @ActiveProfiles("test") public class UserServiceIntegrationTest { // Test metodları }
b) Birden fazla profil etkinleştirme:
java@SpringBootTest @ActiveProfiles({"test", "dev"}) public class UserServiceIntegrationTest { // Test metodları }
- Pratik Bir Örnek:
Diyelim ki uygulamanızda farklı veritabanı konfigürasyonları için profiller kullanıyorsunuz. Test ortamı için ayrı bir veritabanı konfigürasyonu oluşturmak istiyorsunuz.
application.properties (veya application.yml):
propertiesspring.datasource.url=jdbc:mysql://localhost:3306/production_db spring.datasource.username=prod_user spring.datasource.password=prod_password
application-test.properties:
propertiesspring.datasource.url=jdbc:h2:mem:testdb spring.datasource.driverClassName=org.h2.Driver spring.datasource.username=sa spring.datasource.password= spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
Test sınıfı:
java@SpringBootTest @ActiveProfiles("test") public class UserRepositoryIntegrationTest { @Autowired private UserRepository userRepository; @Autowired private DataSource dataSource; @Test public void testDataSource() throws SQLException { assertNotNull(dataSource); assertNotNull(dataSource.getConnection()); assertEquals("H2", dataSource.getConnection().getMetaData().getDatabaseProductName()); } @Test public void testCreateUser() { User user = new User(null, "John Doe", "john@example.com"); User savedUser = userRepository.save(user); assertNotNull(savedUser.getId()); assertEquals("John Doe", savedUser.getName()); } }
Bu örnekte:
- @ActiveProfiles("test") ile "test" profilini etkinleştiriyoruz.
- Bu, Spring Boot'un
application-test.propertiesdosyasındaki konfigürasyonları kullanmasını sağlar. - Testler, gerçek MySQL veritabanı yerine in-memory H2 veritabanı üzerinde çalışır.
- Profilleri Dinamik Olarak Belirleme:
Bazen profilleri programatik olarak belirlemek isteyebilirsiniz. Bunun için özel bir test konfigürasyon sınıfı kullanabilirsiniz:
javapublic class TestProfileResolver implements ActiveProfilesResolver { @Override public String[] resolve(Class<?> testClass) { // Burada mantığınıza göre profilleri belirleyebilirsiniz return new String[]{"test", "dev"}; } } @SpringBootTest @ActiveProfiles(resolver = TestProfileResolver.class) public class DynamicProfileTest { // Test metodları }
@ActiveProfiles annotasyonu, test ortamınızı özelleştirmenin güçlü bir yoludur. Farklı veritabanları, harici servisler veya özel konfigürasyonlar için ayrı profiller oluşturabilir ve testlerinizde bu profilleri etkinleştirebilirsiniz. Bu, testlerinizin izole ve tekrarlanabilir olmasını sağlar.
Testcontainers, testleriniz için gerçek veritabanlarını ve diğer bağımlılıkları Docker konteynerlerinde çalıştırmanıza olanak tanıyan güçlü bir Java kütüphanesidir. Bu, testlerinizi daha gerçekçi ve güvenilir hale getirir. İşte Testcontainers'ın Spring Boot testlerinde nasıl kullanılacağına dair detaylı bir açıklama ve örnekler:
- Testcontainers Kurulumu:
İlk olarak, projenize Testcontainers bağımlılıklarını eklemelisiniz. Maven için pom.xml dosyanıza şu bağımlılıkları ekleyin:
xml<dependency> <groupId>org.testcontainers</groupId> <artifactId>testcontainers</artifactId> <version>1.17.3</version> <scope>test</scope> </dependency> <dependency> <groupId>org.testcontainers</groupId> <artifactId>junit-jupiter</artifactId> <version>1.17.3</version> <scope>test</scope> </dependency> <dependency> <groupId>org.testcontainers</groupId> <artifactId>postgresql</artifactId> <version>1.17.3</version> <scope>test</scope> </dependency>
- Testcontainers Kullanımı:
İşte PostgreSQL veritabanı kullanan bir Spring Boot uygulaması için Testcontainers örneği:
javaimport org.junit.jupiter.api.Test; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.test.context.DynamicPropertyRegistry; import org.springframework.test.context.DynamicPropertySource; import org.testcontainers.containers.PostgreSQLContainer; import org.testcontainers.junit.jupiter.Container; import org.testcontainers.junit.jupiter.Testcontainers; @SpringBootTest @Testcontainers public class UserRepositoryIntegrationTest { @Container static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:13") .withDatabaseName("testdb") .withUsername("test") .withPassword("test"); @DynamicPropertySource static void registerPgProperties(DynamicPropertyRegistry registry) { registry.add("spring.datasource.url", postgres::getJdbcUrl); registry.add("spring.datasource.username", postgres::getUsername); registry.add("spring.datasource.password", postgres::getPassword); } @Autowired private UserRepository userRepository; @Test public void testCreateUser() { User user = new User(null, "John Doe", "john@example.com"); User savedUser = userRepository.save(user); assertNotNull(savedUser.getId()); assertEquals("John Doe", savedUser.getName()); } }
Bu örnekte:
- @Testcontainers annotasyonu, JUnit 5 ile Testcontainers'ı entegre eder.
- @Container annotasyonu, PostgreSQL konteynerini oluşturur ve yönetir.
- @DynamicPropertySource, Spring context'e dinamik olarak veritabanı bağlantı bilgilerini sağlar.
- Özel Konteyner Konfigürasyonu:
Testcontainers'ı daha özel gereksinimleriniz için yapılandırabilirsiniz:
java@Container static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:13") .withDatabaseName("testdb") .withUsername("test") .withPassword("test") .withInitScript("init.sql") .withCommand("postgres -c max_connections=100 -c shared_buffers=256MB");
- Birden Fazla Konteyner Kullanımı:
Testlerinizde birden fazla konteyner kullanabilirsiniz. Örneğin, PostgreSQL ve Redis:
java@Container static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:13"); @Container static GenericContainer<?> redis = new GenericContainer<>("redis:6") .withExposedPorts(6379); @DynamicPropertySource static void registerProperties(DynamicPropertyRegistry registry) { registry.add("spring.datasource.url", postgres::getJdbcUrl); registry.add("spring.datasource.username", postgres::getUsername); registry.add("spring.datasource.password", postgres::getPassword); registry.add("spring.redis.host", redis::getHost); registry.add("spring.redis.port", redis::getFirstMappedPort); }
- Testcontainers ve Docker Compose:
Daha karmaşık test senaryoları için, Docker Compose dosyanızı Testcontainers ile kullanabilirsiniz:
java@Container private static final DockerComposeContainer<?> environment = new DockerComposeContainer<>(new File("src/test/resources/docker-compose.yml")) .withExposedService("postgres_1", 5432) .withExposedService("redis_1", 6379); @DynamicPropertySource static void registerProperties(DynamicPropertyRegistry registry) { registry.add("spring.datasource.url", () -> String.format("jdbc:postgresql://%s:%d/testdb", environment.getServiceHost("postgres_1", 5432), environment.getServicePort("postgres_1", 5432))); // Diğer özellikler... }
Testcontainers kullanmanın avantajları:
- Gerçekçi test ortamı: Gerçek veritabanları ve servislerle çalışırsınız.
- İzolasyon: Her test kendi temiz konteynerinde çalışır.
- Taşınabilirlik: Testler herhangi bir ortamda (CI/CD sistemleri dahil) çalışabilir.
- Esneklik: Çeşitli veritabanları ve servisleri kolayca entegre edebilirsiniz.
Testcontainers, entegrasyon testlerinizi daha güvenilir ve gerçekçi hale getirmenin güçlü bir yoludur. Gerçek veritabanları ve servislerle çalışmanıza olanak tanıyarak, uygulamanızın gerçek dünya senaryolarında nasıl davranacağını daha iyi anlamanızı sağlar.