Spring 컨테이너 전환

package board;

import board.member.LoginService;
import board.member.MemberRegistrationService;
import board.member.MemberRepository;
import board.member.MemoryMemberRepository;
import board.member.PasswordHasher;
import board.member.PasswordHashSettings;
import board.member.Pbkdf2PasswordHasher;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration(proxyBeanMethods = false)
public final class BoardConfig {
    @Bean
    public MemberRepository memberRepository() {
        return new MemoryMemberRepository();
    }

    @Bean
    public PasswordHasher passwordHasher() {
        return new Pbkdf2PasswordHasher(
                PasswordHashSettings.productionDefaults());
    }

    @Bean
    public MemberRegistrationService memberRegistrationService(
            MemberRepository members,
            PasswordHasher passwordHasher
    ) {
        return new MemberRegistrationService(
                members, passwordHasher);
    }

    @Bean
    public LoginService loginService(
            MemberRepository members,
            PasswordHasher passwordHasher
    ) {
        return new LoginService(members, passwordHasher);
    }
}

package board;

import board.member.LoginService;
import board.member.Member;
import board.member.MemberRegistrationService;
import board.member.SignUpCommand;
import java.util.Objects;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.stereotype.Component;

@Component
public final class BoardApplication {
    private final MemberRegistrationService registration;
    private final LoginService login;

    public BoardApplication(
            MemberRegistrationService registration,
            LoginService login
    ) {
        this.registration = Objects.requireNonNull(
                registration, "registration must not be null");
        this.login = Objects.requireNonNull(
                login, "login must not be null");
    }

    public long registerAndAuthenticate(SignUpCommand command) {
        Objects.requireNonNull(command, "command must not be null");

        Member registered = registration.register(command);
        long loginId = login.authenticate(
                command.email(), command.rawPassword());

        if (registered.id() != loginId) {
            throw new IllegalStateException(
                    "composition returned different member ids");
        }
        return loginId;
    }

    public static void main(String[] args) {
        try (var context =
                     new AnnotationConfigApplicationContext()) {
            context.register(
                    BoardConfig.class, BoardApplication.class);
            context.refresh();

            long memberId = context.getBean(BoardApplication.class)
                    .registerAndAuthenticate(new SignUpCommand(
                            "[email protected]",
                            "안동민",
                            "secret-1234"));
            System.out.println("memberId=" + memberId);
        }
    }
}

memberId=1

package board;

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

import board.member.MemberRegistrationService;
import board.member.MemberRepository;
import board.member.MemoryMemberRepository;
import board.member.PasswordHasher;
import board.member.SignUpCommand;
import board.member.TestPasswordHasher;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.NoUniqueBeanDefinitionException;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

final class BoardConfigTest {
    @Test
    void 단일_생성자에_서비스를_주입해_같은_저장_상태를_사용한다() {
        try (var context = contextWith(
                BoardConfig.class, BoardApplication.class)) {
            long memberId = context.getBean(BoardApplication.class)
                    .registerAndAuthenticate(new SignUpCommand(
                            "[email protected]",
                            "회원",
                            "secret-1234"));

            assertThat(memberId).isPositive();
            assertThat(context.getBean(MemberRepository.class))
                    .isSameAs(context.getBean(MemberRepository.class));
        }
    }

    @Test
    void 기본_singleton은_컨텍스트별_빈_정의에_한정된다() {
        try (var first = contextWith(BoardConfig.class);
             var second = contextWith(BoardConfig.class)) {
            assertThat(first.getBean(MemberRepository.class))
                    .isNotSameAs(second.getBean(MemberRepository.class));
        }
    }

    @Test
    void 저장소_후보가_없으면_refresh가_실패한다() {
        try (var context =
                     new AnnotationConfigApplicationContext()) {
            context.register(MissingRepositoryConfig.class);

            assertThatThrownBy(context::refresh)
                    .hasRootCauseExactlyInstanceOf(
                            NoSuchBeanDefinitionException.class);
        }
    }

    @Test
    void 저장소_후보가_복수이고_선택_기준이_없으면_refresh가_실패한다() {
        try (var context =
                     new AnnotationConfigApplicationContext()) {
            context.register(AmbiguousRepositoryConfig.class);

            assertThatThrownBy(context::refresh)
                    .hasRootCauseExactlyInstanceOf(
                            NoUniqueBeanDefinitionException.class);
        }
    }

    private static AnnotationConfigApplicationContext contextWith(
            Class<?>... componentClasses
    ) {
        var context = new AnnotationConfigApplicationContext();
        context.register(componentClasses);
        context.refresh();
        return context;
    }

    @Configuration(proxyBeanMethods = false)
    static class MissingRepositoryConfig {
        @Bean
        PasswordHasher passwordHasher() {
            return new TestPasswordHasher();
        }

        @Bean
        MemberRegistrationService memberRegistrationService(
                MemberRepository missingRepository,
                PasswordHasher passwordHasher
        ) {
            return new MemberRegistrationService(
                    missingRepository, passwordHasher);
        }
    }

    @Configuration(proxyBeanMethods = false)
    static class AmbiguousRepositoryConfig {
        @Bean
        MemberRepository firstRepository() {
            return new MemoryMemberRepository();
        }

        @Bean
        MemberRepository secondRepository() {
            return new MemoryMemberRepository();
        }

        @Bean
        PasswordHasher passwordHasher() {
            return new TestPasswordHasher();
        }

        @Bean
        MemberRegistrationService memberRegistrationService(
                MemberRepository ambiguousRepository,
                PasswordHasher passwordHasher
        ) {
            return new MemberRegistrationService(
                    ambiguousRepository, passwordHasher);
        }
    }
}