Spring Boot Pre-Interview Guide Part 2: Database & Testing

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/app
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: app
    password: secret
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
    properties:
      hibernate:
        format_sql: true

Combinations you must NEVER use

• Production + create = Deletes all existing data
• Production + create-drop = Drops tables on application shutdown
• Production + update = Unexpected schema changes (columns won’t be deleted, but additions/modifications will occur)

Recommended settings per environment

Practical Tips

In production, use DB migration tools like Flyway or Liquibase to manage schemas. Relying on ddl-auto can cause unexpected data loss.

# Production environment configuration example
spring:
  jpa:
    hibernate:
      ddl-auto: validate  # or none
  flyway:
    enabled: true

Flyway vs Liquibase Comparison

# Flyway migration file structure
src/main/resources/db/migration/
├── V1__create_member_table.sql
├── V2__create_product_table.sql
└── V3__add_category_column.sql

Recommendation for tasks: For simple tasks, ddl-auto: create-drop (local) + validate (Docker) is sufficient. Migration tools are more important in production environments.

spring:
  datasource:
    url: jdbc:h2:mem:testdb
    driver-class-name: org.h2.Driver
    username: sa
    password:
  h2:
    console:
      enabled: true
      path: /h2-console
  jpa:
    hibernate:
      ddl-auto: create-drop
    show-sql: true

dependencies {
    runtimeOnly 'com.h2database:h2'
    // Separate dependency required for Spring Boot 4.x and above
    runtimeOnly 'org.springframework.boot:spring-boot-h2console'
}

@Repository
public class MemoryProductRepository implements ProductRepository {

    // Use ConcurrentHashMap for thread safety
    private final Map<Long, Product> store = new ConcurrentHashMap<>();
    private final AtomicLong sequence = new AtomicLong(0);

    @Override
    public Product save(Product product) {
        if (product.getId() == null) {
            product.setId(sequence.incrementAndGet());
        }
        store.put(product.getId(), product);
        return product;
    }

    @Override
    public Optional<Product> findById(Long id) {
        return Optional.ofNullable(store.get(id));
    }

    @Override
    public List<Product> findAll() {
        return new ArrayList<>(store.values());
    }

    @Override
    public void deleteById(Long id) {
        store.remove(id);
    }
}

ID Generation Strategy

In a JPA environment, @GeneratedValue automatically generates IDs, but in a memory storage, you need to implement it yourself.

// Bad example - concurrency issue
private long sequence = 0;
product.setId(++sequence);  // Race condition possible

// Good example - using AtomicLong
private final AtomicLong sequence = new AtomicLong(0);
product.setId(sequence.incrementAndGet());

Object Copy Warning

If you return a direct reference to a stored object, external modifications will also change the data in the storage.

// Dangerous code
return store.get(id);  // Returns the original

// Safe code (defensive copy)
return store.get(id).copy();  // Or copy with new Product(...)

When Defensive Copying Is Needed

Key point: Since Memory Repository is for testing purposes, it should mimic JPA behavior. In actual JPA, modifying a retrieved entity reflects changes to the DB at transaction commit, but Memory Repository lacks this mechanism, so defensive copying prevents unintended modifications.

Pagination Handling

public Page<Product> findAll(Pageable pageable) {
    List<Product> all = new ArrayList<>(store.values());
    int start = (int) pageable.getOffset();
    int end = Math.min(start + pageable.getPageSize(), all.size());

    List<Product> content = all.subList(start, end);
    return new PageImpl<>(content, pageable, all.size());
}

services:
  mysql-db:
    container_name: mysql-db
    image: mysql:8.0
    restart: unless-stopped
    environment:
      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD:-rootpassword}
      MYSQL_DATABASE: testdb
      MYSQL_USER: ${MYSQL_USER:-user}
      MYSQL_PASSWORD: ${MYSQL_PASSWORD:-password}
      TZ: Asia/Seoul
    ports:
      - "3306:3306"
    volumes:
      - db_data:/var/lib/mysql
    command:
      - --character-set-server=utf8mb4
      - --collation-server=utf8mb4_unicode_ci
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
      interval: 10s
      timeout: 5s
      retries: 5

volumes:
  db_data:

services:
  postgres-db:
    container_name: postgres-db
    image: postgres:15
    restart: unless-stopped
    environment:
      POSTGRES_DB: testdb
      POSTGRES_USER: ${POSTGRES_USER:-user}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-password}
      TZ: Asia/Seoul
    ports:
      - "5432:5432"
    volumes:
      - pg_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-user}"]
      interval: 10s
      timeout: 5s
      retries: 5

volumes:
  pg_data:

@Configuration(proxyBeanMethods = false)
class QuerydslConfig(
    private val entityManager: EntityManager
) {
    @Bean
    fun jpaQueryFactory(): JPAQueryFactory {
        return JPAQueryFactory(entityManager)
    }
}

dependencies {
    implementation("com.querydsl:querydsl-jpa:5.0.0:jakarta")
    kapt("com.querydsl:querydsl-apt:5.0.0:jakarta")
}

spring:
  datasource:
    url: jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE
    driver-class-name: org.h2.Driver
    username: sa
    password:
  jpa:
    hibernate:
      ddl-auto: create-drop
    show-sql: true

dependencies {
    testRuntimeOnly 'com.h2database:h2'
}

tasks.named('test') {
    useJUnitPlatform()
    systemProperty 'spring.profiles.active', 'test'
}

@DataJpaTest

• Loads only JPA-related beans, so it’s fast
• @Transactional is applied by default for auto-rollback
• Service, Controller, etc. are not loaded
• Suitable for pure Repository logic testing

@SpringBootTest

• Loads the entire ApplicationContext, so it’s slow
• Integration testing similar to actual environment
• All beans are injected, enabling E2E testing

Selection Guide

Practical Tips

If test speed matters, actively use Slice Tests (@DataJpaTest, @WebMvcTest), and only use @SpringBootTest for key integration test scenarios.

When mock objects are appropriate

• External API calls (payment, notifications, etc.)
• Hard-to-test dependencies (time, random, etc.)
• When testing only a specific layer in unit tests
• Error scenario simulation

When real objects are appropriate

• Verifying actual DB interactions
• Query performance testing
• Transaction behavior verification
• Relationship mapping verification

Warning: Problems with excessive mocking

// Bad - excessive mocking makes the test meaningless
given(repository.save(any())).willReturn(product);
given(repository.findById(1L)).willReturn(Optional.of(product));

Product saved = service.create(request);  // calls save()
Product found = service.find(1L);         // calls findById()

// These might not be the same object in reality, but mocking always succeeds
assertThat(found.getId()).isEqualTo(saved.getId());

Ways to reduce excessive mocking

// Good - using Fake Repository
class ProductServiceTest {
    private ProductService service;
    private FakeProductRepository repository;  // Memory implementation

    @BeforeEach
    void setUp() {
        repository = new FakeProductRepository();
        service = new ProductService(repository);
    }

    @Test
    void save_and_retrieve_product() {
        // Given
        CreateProductRequest request = new CreateProductRequest("Product", 1000);

        // When
        Long savedId = service.create(request);
        Product found = service.findById(savedId);

        // Then - verifies actual save/retrieve behavior
        assertThat(found.getName()).isEqualTo("Product");
    }
}

Practical Tips

• Integration tests: all real objects

@DataJpaTest
class ProductRepositoryTest {

    @Autowired
    private ProductRepository productRepository;

    @Test
    @DisplayName("Product save test")
    void saveProduct() {
        // given
        Product product = new Product("Test Product", 10000);

        // when
        Product saved = productRepository.save(product);

        // then
        assertThat(saved.getId()).isNotNull();
        assertThat(saved.getName()).isEqualTo("Test Product");
    }

    @Test
    @DisplayName("Product find by ID test")
    void findById() {
        // given
        Product product = productRepository.save(new Product("Test Product", 10000));

        // when
        Optional<Product> found = productRepository.findById(product.getId());

        // then
        assertThat(found).isPresent();
        assertThat(found.get().getName()).isEqualTo("Test Product");
    }
}

@ExtendWith(MockitoExtension.class)
class ProductServiceTest {

    @Mock
    private ProductRepository productRepository;

    @InjectMocks
    private ProductService productService;

    @Test
    @DisplayName("Product creation test")
    void createProduct() {
        // given
        ProductRequest request = new ProductRequest("Test Product", 10000);
        Product product = new Product(1L, "Test Product", 10000);

        given(productRepository.save(any(Product.class))).willReturn(product);

        // when
        ProductResponse response = productService.create(request);

        // then
        assertThat(response.getName()).isEqualTo("Test Product");
        verify(productRepository, times(1)).save(any(Product.class));
    }
}

@WebMvcTest(ProductController.class)
class ProductControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private ProductService productService;

    @Autowired
    private ObjectMapper objectMapper;

    @Test
    @DisplayName("Product creation API test")
    void createProduct() throws Exception {
        // given
        ProductRequest request = new ProductRequest("Test Product", 10000);
        ProductResponse response = new ProductResponse(1L, "Test Product", 10000);

        given(productService.create(any())).willReturn(response);

        // when & then
        mockMvc.perform(post("/api/products")
                .contentType(MediaType.APPLICATION_JSON)
                .content(objectMapper.writeValueAsString(request)))
            .andExpect(status().isCreated())
            .andExpect(jsonPath("$.id").value(1))
            .andExpect(jsonPath("$.name").value("Test Product"));
    }
}

@DataJpaTest
class ProductRepositoryTest(
    private val productRepository: ProductRepository
) : FunSpec({

    test("Save product") {
        // given
        val product = Product(name = "Test Product", price = 10000)

        // when
        val saved = productRepository.save(product)

        // then
        saved.id shouldNotBe null
        saved.name shouldBe "Test Product"
    }
})

class ProductServiceTest : BehaviorSpec({

    val productRepository = mockk<ProductRepository>()
    val productService = ProductService(productRepository)

    Given("a product creation request is given") {
        val request = ProductRequest(name = "Test Product", price = 10000)
        val product = Product(id = 1L, name = "Test Product", price = 10000)

        every { productRepository.save(any()) } returns product

        When("creating a product") {
            val response = productService.create(request)

            Then("the product is created successfully") {
                response.name shouldBe "Test Product"
                verify(exactly = 1) { productRepository.save(any()) }
            }
        }
    }
})

Writing in Kotest style enables more expressive tests.

@WebMvcTest(ProductController::class)
class ProductControllerKotestTest(
    private val mockMvc: MockMvc,
    @MockkBean private val productService: ProductService
) : DescribeSpec({

    val objectMapper = ObjectMapper().registerModule(JavaTimeModule())

    describe("POST /api/v1/products") {
        context("when a valid request is given") {
            it("returns 201 Created with the created product ID") {
                val request = RegisterProductRequest(name = "Test Product", price = 10000)
                every { productService.registerProduct(any()) } returns 1L

                mockMvc.perform(
                    post("/api/v1/products")
                        .contentType(MediaType.APPLICATION_JSON)
                        .content(objectMapper.writeValueAsString(request))
                )
                    .andExpect(status().isCreated)
                    .andExpect(jsonPath("$.data").value(1))
            }
        }

        context("when the product name is empty") {
            it("returns 400 Bad Request") {
                val invalidRequest = mapOf("name" to "", "price" to 10000)

                mockMvc.perform(
                    post("/api/v1/products")
                        .contentType(MediaType.APPLICATION_JSON)
                        .content(objectMapper.writeValueAsString(invalidRequest))
                )
                    .andExpect(status().isBadRequest)
            }
        }
    }

    describe("GET /api/v1/products/{productId}") {
        context("when querying with an existing product ID") {
            it("returns 200 OK with product information") {
                val response = FindProductDetailResponse(
                    id = 1L,
                    name = "Test Product",
                    price = 10000,
                    category = ProductCategoryType.FOOD,
                    enabled = true,
                    createdAt = LocalDateTime.now()
                )
                every { productService.findProductDetail(1L) } returns response

                mockMvc.perform(get("/api/v1/products/1"))
                    .andExpect(status().isOk)
                    .andExpect(jsonPath("$.data.name").value("Test Product"))
            }
        }

        context("when querying with a non-existing product ID") {
            it("returns 404 Not Found") {
                every { productService.findProductDetail(999L) } throws NotFoundException()

                mockMvc.perform(get("/api/v1/products/999"))
                    .andExpect(status().isNotFound)
            }
        }
    }
})

@WebMvcTest(UserController.class)
class UserControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    @WithMockUser(username = "test@test.com", roles = {"USER"})
    void getUserProfile() throws Exception {
        mockMvc.perform(get("/api/users/me"))
            .andExpect(status().isOk());
    }
}

@BeforeEach
fun setUp() {
    SecurityContextHolder.getContext().authentication =
        PreAuthenticatedAuthenticationToken(
            "test@test.com",
            null,
            listOf(SimpleGrantedAuthority("ROLE_USER"))
        )
}

@TestConfiguration
public class TestSecurityConfig {

    @Bean
    public SecurityFilterChain testSecurityFilterChain(HttpSecurity http) throws Exception {
        return http
            .csrf(AbstractHttpConfigurer::disable)
            .authorizeHttpRequests(auth -> auth.anyRequest().permitAll())
            .build();
    }
}

@WebMvcTest(UserController.class)
@Import(TestSecurityConfig.class)
class UserControllerTest {
    // test code
}

H2 In-Memory DB

Testcontainers

Selection Guide

• Use H2: Most CRUD operations, pre-interview tasks, when fast feedback is needed
• Use Testcontainers:
  • When using native queries or DB-specific functions
  • Testing specific features like JSON columns, full-text search
  • When same query plan verification as production is needed

Recommendation for tasks

For most pre-interview tasks, H2 is sufficient. Only consider Testcontainers when using MySQL/PostgreSQL-specific features.

dependencies {
    testImplementation 'org.testcontainers:testcontainers:1.19.0'
    testImplementation 'org.testcontainers:mysql:1.19.0'
    testImplementation 'org.testcontainers:junit-jupiter:1.19.0'
}

@SpringBootTest
@Testcontainers
class IntegrationTest {

    @Container
    static MySQLContainer<?> mysql = new MySQLContainer<>("mysql:8.0")
        .withDatabaseName("testdb")
        .withUsername("test")
        .withPassword("test");

    @DynamicPropertySource
    static void configureProperties(DynamicPropertyRegistry registry) {
        registry.add("spring.datasource.url", mysql::getJdbcUrl);
        registry.add("spring.datasource.username", mysql::getUsername);
        registry.add("spring.datasource.password", mysql::getPassword);
    }
}

The Coverage Target Debate

• 100% advocates: All code must be tested for safety
• Pragmatists: Testing important business logic is sufficient

The Reality in Practice

Recommendation for tasks

In time-limited tasks, you don’t need to test all code. Write tests in this priority order:

1. Required: Core business logic in the Service layer
2. Recommended: Complex Querydsl queries, exception handling
3. Optional: Controller tests, simple CRUD

Having tests is better than none, but meaningless tests (getter/setter tests, etc.) are actually a negative.

// Bad - meaningless test
@Test
void getterTest() {
    Product p = new Product("test", 1000);
    assertThat(p.getName()).isEqualTo("test");
}

// Good - meaningful test
@Test
void throws_exception_when_stock_is_insufficient() {
    Product product = new Product("test", 1000, 5);
    assertThrows(InsufficientStockException.class,
        () -> product.decreaseStock(10));
}