테스트는 unit, slice, integration을 어떻게 나눠야 할까요?

dependencies {
    testImplementation 'org.springframework.boot:spring-boot-starter-webmvc-test'
    testImplementation 'org.springframework.boot:spring-boot-starter-jdbc-test'
    testImplementation 'org.springframework.boot:spring-boot-starter-security-test'
    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
}

package me.nvim.blog.auth.identity.domain;

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

import java.util.List;

import org.junit.jupiter.api.Test;

class UserAccountTests {

    @Test
    void registrationNormalizesEmailAndAssignsUserRole() {
        UserAccount userAccount = UserAccount.register(
                "User@Example.COM",
                "password-hash",
                "User");

        assertEquals("user@example.com", userAccount.email());
        assertEquals(List.of("ROLE_USER"), userAccount.roles());
    }
}

package me.nvim.blog.auth.identity.application;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;

import org.junit.jupiter.api.Test;

import me.nvim.blog.auth.identity.domain.PasswordHasher;
import me.nvim.blog.auth.identity.domain.RefreshTokenRepository;
import me.nvim.blog.auth.identity.domain.TokenIssuer;
import me.nvim.blog.auth.identity.domain.UserAccount;
import me.nvim.blog.auth.identity.domain.UserAccountRepository;

class IdentityFacadeTests {

    @Test
    void registrationHashesPasswordBeforeSaving() {
        UserAccountRepository users = mock(UserAccountRepository.class);
        PasswordHasher passwords = mock(PasswordHasher.class);
        RefreshTokenRepository refreshTokens = mock(RefreshTokenRepository.class);
        TokenIssuer tokens = mock(TokenIssuer.class);

        given(passwords.hash("correct-password")).willReturn("encoded-password");
        given(users.save(any(UserAccount.class)))
                .willAnswer(invocation -> invocation.getArgument(0));

        IdentityFacade facade = new IdentityFacade(users, refreshTokens, passwords, tokens);

        AccountResult result = facade.register(new RegisterAccountCommand(
                "User@Example.COM",
                "correct-password",
                "User"));

        assertEquals("user@example.com", result.email());
    }
}

package me.nvim.blog.auth.identity.presentation;

import static org.mockito.ArgumentMatchers.any;
import static org.mockito.BDDMockito.given;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

import java.time.Instant;
import java.util.List;
import java.util.UUID;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.webmvc.test.autoconfigure.AutoConfigureMockMvc;
import org.springframework.boot.webmvc.test.autoconfigure.WebMvcTest;
import org.springframework.http.MediaType;
import org.springframework.test.context.bean.override.mockito.MockitoBean;
import org.springframework.test.web.servlet.MockMvc;

import me.nvim.blog.auth.identity.application.AccountResult;
import me.nvim.blog.auth.identity.application.IdentityFacade;

@WebMvcTest(AccountController.class)
@AutoConfigureMockMvc(addFilters = false)
class AccountControllerTests {

    @Autowired
    private MockMvc mvc;

    @MockitoBean
    private IdentityFacade identityFacade;

    @Test
    void validRegistrationReturnsCreatedResponse() throws Exception {
        given(this.identityFacade.register(any())).willReturn(new AccountResult(
                UUID.fromString("00000000-0000-0000-0000-000000000001"),
                "user@example.com",
                "User",
                true,
                Instant.parse("2026-07-20T00:00:00Z"),
                List.of("ROLE_USER")));

        this.mvc.perform(post("/api/auth/register")
                        .contentType(MediaType.APPLICATION_JSON)
                        .content("""
                                {
                                  "email": "user@example.com",
                                  "password": "correct-password",
                                  "displayName": "User"
                                }
                                """))
                .andExpect(status().isCreated())
                .andExpect(jsonPath("$.email").value("user@example.com"));
    }
}

package me.nvim.blog.auth.identity.infrastructure.jdbc;

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

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.jdbc.test.autoconfigure.JdbcTest;
import org.springframework.context.annotation.Import;
import org.springframework.test.context.jdbc.Sql;

import me.nvim.blog.auth.identity.domain.UserAccount;

@JdbcTest(properties = "spring.sql.init.mode=never")
@Import(JdbcUserAccountRepository.class)
@Sql({"/schema.sql", "/data.sql"})
class JdbcUserAccountRepositoryTests {

    @Autowired
    private JdbcUserAccountRepository repository;

    @Test
    void savesAndReadsRolesWithUser() {
        UserAccount saved = this.repository.save(UserAccount.register(
                "User@Example.COM",
                "encoded-password",
                "User"));

        UserAccount found = this.repository.findById(saved.id()).orElseThrow();

        assertEquals("user@example.com", found.email());
        assertEquals("ROLE_USER", found.roles().getFirst());
    }
}

package me.nvim.blog.auth.identity.presentation;

import static org.assertj.core.api.Assertions.assertThat;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.resttestclient.autoconfigure.AutoConfigureRestTestClient;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
import org.springframework.test.web.servlet.client.RestTestClient;
import org.springframework.test.web.servlet.client.RestTestClient.ResponseSpec;
import org.springframework.test.web.servlet.client.assertj.RestTestClientResponse;

@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
@AutoConfigureRestTestClient
class AuthApiServerTests {

    @Test
    void healthIsReachableThroughHttp(@Autowired RestTestClient client) {
        ResponseSpec spec = client.get().uri("/actuator/health").exchange();
        RestTestClientResponse response = RestTestClientResponse.from(spec);

        assertThat(response).hasStatusOk();
        assertThat(response).bodyJson()
                .extractingPath("$.status").asString().isEqualTo("UP");
    }
}