의존관계 주입 방식

package example.injection;

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

import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Objects;
import org.junit.jupiter.api.Test;

final class RequiredConstructorContractTest {
    interface MemberStore {
        long save(String email, String passwordHash);
    }

    interface PasswordEncoder {
        String encode(String rawPassword);
    }

    static final class RegistrationUseCase {
        private final MemberStore members;
        private final PasswordEncoder passwords;

        RegistrationUseCase(
                MemberStore members,
                PasswordEncoder passwords
        ) {
            this.members = Objects.requireNonNull(
                    members, "members must not be null");
            this.passwords = Objects.requireNonNull(
                    passwords, "passwords must not be null");
        }

        long register(String email, String rawPassword) {
            return members.save(email, passwords.encode(rawPassword));
        }
    }

    @Test
    void 순수_Java로_완성된_객체를_직접_검증한다() {
        var saved = new ArrayList<String>();
        MemberStore members = (email, passwordHash) -> {
            saved.add(email + ":" + passwordHash);
            return 41L;
        };
        PasswordEncoder passwords = raw -> "{test}" + raw.length();
        var useCase = new RegistrationUseCase(members, passwords);

        long memberId = useCase.register(
                "[email protected]", "secret-1234");

        assertThat(memberId).isEqualTo(41L);
        assertThat(saved).containsExactly(
                "[email protected]:{test}11");
        for (var field : RegistrationUseCase.class.getDeclaredFields()) {
            assertThat(Modifier.isFinal(field.getModifiers())).isTrue();
        }
    }

    @Test
    void 필수_참조의_null을_생성자에서_거부한다() {
        MemberStore members = (email, passwordHash) -> 1L;
        PasswordEncoder passwords = raw -> raw;

        assertThatNullPointerException()
                .isThrownBy(() -> new RegistrationUseCase(
                        null, passwords))
                .withMessage("members must not be null");
        assertThatNullPointerException()
                .isThrownBy(() -> new RegistrationUseCase(
                        members, null))
                .withMessage("passwords must not be null");
    }
}

package example.injection;

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

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.BeanCreationException;
import org.springframework.beans.factory.BeanCurrentlyInCreationException;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

final class ConstructorCycleTest {
    static final class CyclicRegistrationService {
        private final CyclicReportService reports;

        CyclicRegistrationService(CyclicReportService reports) {
            this.reports = Objects.requireNonNull(reports);
        }
    }

    static final class CyclicReportService {
        private final CyclicRegistrationService registrations;

        CyclicReportService(CyclicRegistrationService registrations) {
            this.registrations = Objects.requireNonNull(registrations);
        }
    }

    @Configuration(proxyBeanMethods = false)
    static class CyclicConfig {
        @Bean
        CyclicRegistrationService cyclicRegistrationService(
                CyclicReportService reports
        ) {
            return new CyclicRegistrationService(reports);
        }

        @Bean
        CyclicReportService cyclicReportService(
                CyclicRegistrationService registrations
        ) {
            return new CyclicReportService(registrations);
        }
    }

    @FunctionalInterface
    interface RegistrationEvents {
        void memberRegistered(long memberId);
    }

    static final class RegistrationService {
        private final RegistrationEvents events;

        RegistrationService(RegistrationEvents events) {
            this.events = Objects.requireNonNull(events);
        }

        void register(long memberId) {
            events.memberRegistered(memberId);
        }
    }

    static final class ReportProjector implements RegistrationEvents {
        private final List<Long> memberIds = new ArrayList<>();

        @Override
        public void memberRegistered(long memberId) {
            memberIds.add(memberId);
        }

        List<Long> snapshot() {
            return List.copyOf(memberIds);
        }
    }

    @Configuration(proxyBeanMethods = false)
    static class RefactoredConfig {
        @Bean
        ReportProjector reportProjector() {
            return new ReportProjector();
        }

        @Bean
        RegistrationService registrationService(
                ReportProjector reports
        ) {
            return new RegistrationService(reports);
        }
    }

    @Test
    void eager_singleton_생성자_순환은_refresh에서_실패한다() {
        try (var context =
                     new AnnotationConfigApplicationContext()) {
            context.register(CyclicConfig.class);

            assertThatThrownBy(context::refresh)
                    .isInstanceOf(BeanCreationException.class)
                    .hasRootCauseExactlyInstanceOf(
                            BeanCurrentlyInCreationException.class);
        }
    }

    @Test
    void 후속_반응을_이벤트_포트로_바꾸면_방향이_하나가_된다() {
        try (var context = new AnnotationConfigApplicationContext(
                RefactoredConfig.class)) {
            context.getBean(RegistrationService.class).register(7L);

            assertThat(context.getBean(ReportProjector.class).snapshot())
                    .containsExactly(7L);
        }
    }
}

package example.injection;

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

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

final class NullObjectCompositionTest {
    @FunctionalInterface
    interface AuditSink {
        void memberRegistered(long memberId);

        static AuditSink noOp() {
            return memberId -> {
            };
        }
    }

    static final class RegistrationReporter {
        private final AuditSink auditSink;

        RegistrationReporter(AuditSink auditSink) {
            this.auditSink = Objects.requireNonNull(auditSink);
        }

        void report(long memberId) {
            auditSink.memberRegistered(memberId);
        }
    }

    static final class RecordingAuditSink implements AuditSink {
        private final List<Long> memberIds = new ArrayList<>();

        @Override
        public void memberRegistered(long memberId) {
            memberIds.add(memberId);
        }

        List<Long> snapshot() {
            return List.copyOf(memberIds);
        }
    }

    @Configuration(proxyBeanMethods = false)
    static class ReporterConfig {
        @Bean
        RegistrationReporter registrationReporter(
                ObjectProvider<AuditSink> auditSinks
        ) {
            AuditSink sink = auditSinks.getIfAvailable(
                    AuditSink::noOp);
            return new RegistrationReporter(sink);
        }
    }

    @Configuration(proxyBeanMethods = false)
    @Import(ReporterConfig.class)
    static class NoAuditConfig {
    }

    @Configuration(proxyBeanMethods = false)
    @Import(ReporterConfig.class)
    static class OneAuditConfig {
        @Bean
        RecordingAuditSink recordingAuditSink() {
            return new RecordingAuditSink();
        }
    }

    @Test
    void 후보가_없으면_구성이_no_op을_전달한다() {
        try (var context = new AnnotationConfigApplicationContext(
                NoAuditConfig.class)) {
            var reporter = context.getBean(RegistrationReporter.class);

            assertThatCode(() -> reporter.report(1L))
                    .doesNotThrowAnyException();
        }
    }

    @Test
    void 후보가_하나면_구성이_그_sink를_전달한다() {
        try (var context = new AnnotationConfigApplicationContext(
                OneAuditConfig.class)) {
            context.getBean(RegistrationReporter.class).report(2L);

            assertThat(context.getBean(
                    RecordingAuditSink.class).snapshot())
                    .containsExactly(2L);
        }
    }
}

package example.injection;

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

import java.util.Objects;
import java.util.Optional;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

final class ResolutionTimingTest {
    @FunctionalInterface
    interface AuditSink {
        String name();
    }

    record OptionalReporter(Optional<AuditSink> sink) {
        OptionalReporter {
            Objects.requireNonNull(sink);
        }
    }

    record ProviderReporter(ObjectProvider<AuditSink> sinks) {
        ProviderReporter {
            Objects.requireNonNull(sinks);
        }
    }

    @Configuration(proxyBeanMethods = false)
    static class TimingConfig {
        @Bean
        OptionalReporter optionalReporter(
                Optional<AuditSink> sink
        ) {
            return new OptionalReporter(sink);
        }

        @Bean
        ProviderReporter providerReporter(
                ObjectProvider<AuditSink> sinks
        ) {
            return new ProviderReporter(sinks);
        }
    }

    @Test
    void optional은_snapshot이고_provider는_호출마다_조회한다() {
        try (var context = new AnnotationConfigApplicationContext(
                TimingConfig.class)) {
            var optional = context.getBean(OptionalReporter.class);
            var provider = context.getBean(ProviderReporter.class);

            assertThat(optional.sink()).isEmpty();
            assertThat(provider.sinks().getIfAvailable()).isNull();

            AuditSink lateSink = () -> "late";
            context.getBeanFactory().registerSingleton(
                    "lateAuditSink", lateSink);

            assertThat(optional.sink()).isEmpty();
            assertThat(provider.sinks().getIfAvailable())
                    .isSameAs(lateSink);
        }
    }
}

package example.injection;

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

import org.junit.jupiter.api.Test;
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 ObjectProviderAvailabilityTest {
    @FunctionalInterface
    interface AuditSink {
        String name();

        static AuditSink noOp() {
            return () -> "no-op";
        }
    }

    @Configuration(proxyBeanMethods = false)
    static class EmptyConfig {
    }

    @Configuration(proxyBeanMethods = false)
    static class OneSinkConfig {
        @Bean
        AuditSink fileAuditSink() {
            return () -> "file";
        }
    }

    @Configuration(proxyBeanMethods = false)
    static class AmbiguousSinkConfig {
        @Bean
        AuditSink fileAuditSink() {
            return () -> "file";
        }

        @Bean
        AuditSink httpAuditSink() {
            return () -> "http";
        }
    }

    @Test
    void 후보가_없으면_null과_supplier_결과를_구분한다() {
        try (var context = new AnnotationConfigApplicationContext(
                EmptyConfig.class)) {
            var sinks = context.getBeanProvider(AuditSink.class);

            assertThat(sinks.getIfAvailable()).isNull();
            assertThat(sinks.getIfAvailable(AuditSink::noOp).name())
                    .isEqualTo("no-op");
        }
    }

    @Test
    void unique_winner가_있으면_그_빈을_반환한다() {
        try (var context = new AnnotationConfigApplicationContext(
                OneSinkConfig.class)) {
            var sinks = context.getBeanProvider(AuditSink.class);

            assertThat(sinks.getIfAvailable().name())
                    .isEqualTo("file");
        }
    }

    @Test
    void 선택_메타데이터_없는_복수_후보는_모호하다() {
        try (var context = new AnnotationConfigApplicationContext(
                AmbiguousSinkConfig.class)) {
            var sinks = context.getBeanProvider(AuditSink.class);

            assertThatThrownBy(sinks::getIfAvailable)
                    .isExactlyInstanceOf(
                            NoUniqueBeanDefinitionException.class);
        }
    }
}