순수 Java 회원가입

./gradlew test --tests board.member.MemberRegistrationServiceTest

package board.member;

import java.util.Locale;

public record SignUpCommand(
        String email,
        String name,
        String rawPassword
) {
    public SignUpCommand {
        email = requireEmail(email);
        name = requireText(name, "name", 50);
        requireRawPassword(rawPassword);
    }

    private static String requireEmail(String value) {
        if (value == null) {
            throw new IllegalArgumentException("email is required");
        }
        var normalized = value.strip().toLowerCase(Locale.ROOT);
        if (normalized.isEmpty() || normalized.length() > 254) {
            throw new IllegalArgumentException(
                    "email has an invalid length");
        }
        return normalized;
    }

    private static String requireText(
            String value,
            String field,
            int maxLength
    ) {
        if (value == null) {
            throw new IllegalArgumentException(field + " is required");
        }
        var normalized = value.strip();
        if (normalized.isEmpty() || normalized.length() > maxLength) {
            throw new IllegalArgumentException(
                    field + " has an invalid length");
        }
        return normalized;
    }

    private static void requireRawPassword(String rawPassword) {
        if (rawPassword == null || rawPassword.isBlank()) {
            throw new IllegalArgumentException("rawPassword is required");
        }
        if (rawPassword.length() < 8 || rawPassword.length() > 128) {
            throw new IllegalArgumentException(
                    "rawPassword must be between 8 and 128 UTF-16 code units");
        }
    }
}

package board.member;

import java.util.Locale;
import java.util.Objects;

public record Member(
        long id,
        String email,
        String name,
        String passwordHash
) {
    public Member {
        if (id < 0) {
            throw new IllegalArgumentException("id must not be negative");
        }
        email = requireEmail(email);
        name = requireText(name, "name", 50);
        passwordHash = requirePasswordHash(passwordHash);
    }

    public static Member signUp(
            String email,
            String name,
            String passwordHash
    ) {
        return new Member(0, email, name, passwordHash);
    }

    public Member identifiedBy(long savedId) {
        if (id != 0) {
            throw new IllegalStateException("member already has an id");
        }
        if (savedId < 1) {
            throw new IllegalArgumentException("saved id must be positive");
        }
        return new Member(savedId, email, name, passwordHash);
    }

    private static String requireEmail(String value) {
        Objects.requireNonNull(value, "email must not be null");
        var normalized = value.strip().toLowerCase(Locale.ROOT);
        if (normalized.isEmpty() || normalized.length() > 254) {
            throw new IllegalArgumentException(
                    "email has an invalid length");
        }
        return normalized;
    }

    private static String requireText(
            String value,
            String field,
            int maxLength
    ) {
        Objects.requireNonNull(value, field + " must not be null");
        var normalized = value.strip();
        if (normalized.isEmpty() || normalized.length() > maxLength) {
            throw new IllegalArgumentException(
                    field + " has an invalid length");
        }
        return normalized;
    }

    private static String requirePasswordHash(String value) {
        Objects.requireNonNull(value, "passwordHash must not be null");
        if (value.isBlank()) {
            throw new IllegalArgumentException(
                    "passwordHash must not be blank");
        }
        return value;
    }
}

package board.member;

import java.util.Optional;

public interface MemberRepository {
    boolean existsByEmail(String email);
    Member save(Member member);
    Optional<Member> findByEmail(String email);
}

package board.member;

import java.util.LinkedHashMap;
import java.util.Locale;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;

public final class MemoryMemberRepository implements MemberRepository {
    private final Map<Long, Member> store = new LinkedHashMap<>();
    private long sequence;

    @Override
    public boolean existsByEmail(String email) {
        var normalized = normalizeEmail(email);
        return store.values().stream()
                .anyMatch(member -> member.email().equals(normalized));
    }

    @Override
    public Member save(Member member) {
        Objects.requireNonNull(member, "member must not be null");
        if (member.id() != 0) {
            throw new IllegalStateException("member already has an id");
        }
        long savedId = sequence + 1;
        Member saved = member.identifiedBy(savedId);
        sequence = savedId;
        store.put(saved.id(), saved);
        return saved;
    }

    @Override
    public Optional<Member> findByEmail(String email) {
        var normalized = normalizeEmail(email);
        return store.values().stream()
                .filter(member -> member.email().equals(normalized))
                .findFirst();
    }

    private static String normalizeEmail(String email) {
        Objects.requireNonNull(email, "email must not be null");
        var normalized = email.strip().toLowerCase(Locale.ROOT);
        if (normalized.isEmpty() || normalized.length() > 254) {
            throw new IllegalArgumentException(
                    "email has an invalid length");
        }
        return normalized;
    }
}

package board.member;

public interface PasswordHasher {
    String hash(String rawPassword);
}

package board.member;

import java.util.Objects;

public final class TestPasswordHasher implements PasswordHasher {
    @Override
    public String hash(String rawPassword) {
        Objects.requireNonNull(
                rawPassword, "rawPassword must not be null");
        return "{test}" + Integer.toHexString(rawPassword.hashCode());
    }
}

package board.member;

public final class DuplicateEmailException extends RuntimeException {
    public DuplicateEmailException(String email) {
        super("email already exists: " + email);
    }
}

package board.member;

import java.util.Objects;

public final class MemberRegistrationService {
    private final MemberRepository members;
    private final PasswordHasher passwordHasher;

    public MemberRegistrationService(
            MemberRepository members,
            PasswordHasher passwordHasher
    ) {
        this.members = Objects.requireNonNull(
                members, "members must not be null");
        this.passwordHasher = Objects.requireNonNull(
                passwordHasher, "passwordHasher must not be null");
    }

    public Member register(SignUpCommand command) {
        Objects.requireNonNull(command, "command must not be null");
        if (members.existsByEmail(command.email())) {
            throw new DuplicateEmailException(command.email());
        }
        String passwordHash = passwordHasher.hash(command.rawPassword());
        return members.save(Member.signUp(
                command.email(), command.name(), passwordHash));
    }
}

package board.member;

import org.junit.jupiter.api.Test;

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

final class MemberRegistrationServiceTest {
    @Test
    void 가입하고_원문_비밀번호는_해시까지만_전달한다() {
        var repository = new MemoryMemberRepository();
        var hasher = new TestPasswordHasher();
        var service = new MemberRegistrationService(
                repository, hasher);
        String rawPassword = " secret-1234 ";

        Member member = service.register(new SignUpCommand(
                " [email protected] ", " 안동민 ", rawPassword));

        assertThat(member.id()).isPositive();
        assertThat(member.email()).isEqualTo("[email protected]");
        assertThat(member.name()).isEqualTo("안동민");
        assertThat(member.passwordHash())
                .isEqualTo(hasher.hash(rawPassword))
                .doesNotContain(rawPassword);
        assertThat(repository.findByEmail(" [email protected] "))
                .contains(member);
    }

    @Test
    void 공백_비밀번호는_서비스_호출_전에_거절한다() {
        var repository = new MemoryMemberRepository();

        assertThatThrownBy(() -> new SignUpCommand(
                "[email protected]", "안동민", "   "))
                .isInstanceOf(IllegalArgumentException.class);
        assertThat(repository.findByEmail("[email protected]"))
                .isEmpty();
    }

    @Test
    void 이메일_길이는_소문자_정규화_뒤에_검사한다() {
        assertThatThrownBy(() -> new SignUpCommand(
                "İ".repeat(254), "안동민", "secret-1234"))
                .isInstanceOf(IllegalArgumentException.class);
    }

    @Test
    void 중복_실패_뒤에는_처음_저장한_회원이_남는다() {
        var repository = new MemoryMemberRepository();
        var service = new MemberRegistrationService(
                repository, new TestPasswordHasher());
        Member first = service.register(new SignUpCommand(
                "[email protected]", "안동민", "secret-1234"));

        assertThatThrownBy(() -> service.register(new SignUpCommand(
                " [email protected] ", "다른 이름", "another-1234")))
                .isInstanceOf(DuplicateEmailException.class);
        assertThat(repository.findByEmail("[email protected]"))
                .contains(first);
    }

    @Test
    void 저장소가_반환한_식별된_회원을_재저장해도_순번을_소비하지_않는다() {
        var repository = new MemoryMemberRepository();
        var hasher = new TestPasswordHasher();
        Member first = repository.save(Member.signUp(
                "[email protected]", "첫 회원",
                hasher.hash("secret-1234")));

        assertThatThrownBy(() -> repository.save(first))
                .isInstanceOf(IllegalStateException.class);

        Member second = repository.save(Member.signUp(
                "[email protected]", "둘째 회원",
                hasher.hash("secret-5678")));
        assertThat(second.id()).isEqualTo(first.id() + 1);
    }
}