HTTP 무상태성과 연결

package board.web;

public record PostSummary(
        long id,
        long memberId,
        String title) {
}

package board.web;

import java.util.List;

@FunctionalInterface
public interface PostQuery {
    List<PostSummary> findAll(long memberId);
}

package board.web;

import java.util.OptionalLong;

@FunctionalInterface
public interface MemberAuthenticator {
    OptionalLong authenticate(String authorizationHeader);
}

package board.web;

import java.util.List;
import java.util.OptionalLong;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api/posts")
public final class StatelessPostController {
    private static final String BEARER_CHALLENGE =
            "Bearer realm=\"board-api\"";

    private final MemberAuthenticator authenticator;
    private final PostQuery query;

    public StatelessPostController(
            MemberAuthenticator authenticator,
            PostQuery query) {
        this.authenticator = authenticator;
        this.query = query;
    }

    @GetMapping
    public ResponseEntity<List<PostSummary>> list(
            @RequestHeader(
                            name = HttpHeaders.AUTHORIZATION,
                            required = false)
                    String authorization) {
        if (authorization == null) {
            return unauthorized();
        }

        OptionalLong memberId =
                authenticator.authenticate(authorization);
        if (memberId.isEmpty()) {
            return unauthorized();
        }

        return ResponseEntity.ok(
                query.findAll(memberId.getAsLong()));
    }

    private static ResponseEntity<List<PostSummary>> unauthorized() {
        return ResponseEntity
                .status(HttpStatus.UNAUTHORIZED)
                .header(
                        HttpHeaders.WWW_AUTHENTICATE,
                        BEARER_CHALLENGE)
                .build();
    }
}

package board.web;

import static java.util.concurrent.TimeUnit.SECONDS;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.List;
import java.util.Objects;
import java.util.OptionalLong;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.atomic.AtomicInteger;
import org.junit.jupiter.api.Test;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
import org.springframework.test.web.servlet.request.MockHttpServletRequestBuilder;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;

class StatelessPostControllerTest {
    private static final String CHALLENGE =
            "Bearer realm=\"board-api\"";

    @Test
    void 현재_요청의_bearer로_7_9_7을_독립적으로_조회한다()
            throws Exception {
        Fixture fixture = fixture();

        assertMember(fixture, "Bearer alice-token", null, 7);
        assertMember(fixture, "Bearer bob-token", null, 9);
        assertMember(
                fixture,
                "Bearer alice-token",
                "9",
                7);

        assertEquals(
                List.of(7L, 9L, 7L),
                fixture.queriedMembers());
    }

    @Test
    void authorization이_없으면_challenge와_401을_반환한다()
            throws Exception {
        Fixture fixture = fixture();

        MvcResult result = perform(
                fixture.mockMvc(), null, null);

        assertUnauthorized(result);
        assertEquals(0, fixture.queryCalls().get());
    }

    @Test
    void 유효하지_않은_bearer는_query를_호출하지_않는다()
            throws Exception {
        Fixture fixture = fixture();

        MvcResult result = perform(
                fixture.mockMvc(),
                "Bearer forged-token",
                "7");

        assertUnauthorized(result);
        assertEquals(0, fixture.queryCalls().get());
    }

    @Test
    void 공유_필드는_두_요청의_member를_결정적으로_섞는다()
            throws Exception {
        StatefulMemberController controller =
                new StatefulMemberController();
        CountDownLatch aliceSelected = new CountDownLatch(1);
        CountDownLatch bobSelected = new CountDownLatch(1);
        ExecutorService pool = Executors.newFixedThreadPool(2);

        try {
            Future<Long> alice = pool.submit(() -> {
                controller.select(7);
                aliceSelected.countDown();
                await(bobSelected);
                return controller.current();
            });
            Future<Long> bob = pool.submit(() -> {
                await(aliceSelected);
                controller.select(9);
                bobSelected.countDown();
                return controller.current();
            });

            assertEquals(9L, alice.get(1, SECONDS));
            assertEquals(9L, bob.get(1, SECONDS));
        } finally {
            stop(pool);
        }
    }

    @Test
    void 같은_stateless_instance도_동시_요청을_독립적으로_처리한다()
            throws Exception {
        StatelessPostController controller = controller(
                new AtomicInteger(),
                new CopyOnWriteArrayList<>());
        CountDownLatch ready = new CountDownLatch(2);
        CountDownLatch start = new CountDownLatch(1);
        ExecutorService pool = Executors.newFixedThreadPool(2);

        try {
            Future<Long> alice = pool.submit(() -> memberFrom(
                    controller,
                    "Bearer alice-token",
                    ready,
                    start));
            Future<Long> bob = pool.submit(() -> memberFrom(
                    controller,
                    "Bearer bob-token",
                    ready,
                    start));

            assertTrue(ready.await(1, SECONDS));
            start.countDown();
            assertEquals(7L, alice.get(1, SECONDS));
            assertEquals(9L, bob.get(1, SECONDS));
        } finally {
            stop(pool);
        }
    }

    private static Fixture fixture() {
        AtomicInteger queryCalls = new AtomicInteger();
        List<Long> queriedMembers =
                new CopyOnWriteArrayList<>();
        StatelessPostController controller =
                controller(queryCalls, queriedMembers);
        ObjectMapper objectMapper = new ObjectMapper();
        MockMvc mockMvc = MockMvcBuilders
                .standaloneSetup(controller)
                .setMessageConverters(
                        new MappingJackson2HttpMessageConverter(
                                objectMapper))
                .build();
        return new Fixture(
                mockMvc,
                objectMapper,
                queryCalls,
                queriedMembers);
    }

    private static StatelessPostController controller(
            AtomicInteger queryCalls,
            List<Long> queriedMembers) {
        MemberAuthenticator authenticator = authorization -> switch (
                authorization) {
            case "Bearer alice-token" -> OptionalLong.of(7);
            case "Bearer bob-token" -> OptionalLong.of(9);
            default -> OptionalLong.empty();
        };
        PostQuery query = memberId -> {
            queryCalls.incrementAndGet();
            queriedMembers.add(memberId);
            return List.of(new PostSummary(
                    memberId * 100,
                    memberId,
                    "HTTP"));
        };
        return new StatelessPostController(authenticator, query);
    }

    private static void assertMember(
            Fixture fixture,
            String authorization,
            String forgedMemberId,
            long expectedMemberId) throws Exception {
        MvcResult result = perform(
                fixture.mockMvc(),
                authorization,
                forgedMemberId);

        assertEquals(200, result.getResponse().getStatus());
        assertEquals(
                MediaType.APPLICATION_JSON_VALUE,
                result.getResponse().getContentType());
        JsonNode body = fixture.objectMapper().readTree(
                result.getResponse().getContentAsByteArray());
        assertTrue(body.isArray());
        assertEquals(1, body.size());
        assertEquals(
                expectedMemberId,
                body.get(0).get("memberId").longValue());
        assertEquals(
                expectedMemberId * 100,
                body.get(0).get("id").longValue());
    }

    private static MvcResult perform(
            MockMvc mockMvc,
            String authorization,
            String forgedMemberId) throws Exception {
        MockHttpServletRequestBuilder request = get("/api/posts")
                .accept(MediaType.APPLICATION_JSON);
        if (authorization != null) {
            request.header(
                    HttpHeaders.AUTHORIZATION,
                    authorization);
        }
        if (forgedMemberId != null) {
            request.header("X-Member-Id", forgedMemberId);
        }
        return mockMvc.perform(request).andReturn();
    }

    private static void assertUnauthorized(MvcResult result)
            throws Exception {
        assertEquals(401, result.getResponse().getStatus());
        assertEquals(
                CHALLENGE,
                result.getResponse().getHeader(
                        HttpHeaders.WWW_AUTHENTICATE));
        assertEquals(
                0,
                result.getResponse().getContentAsByteArray().length);
    }

    private static long memberFrom(
            StatelessPostController controller,
            String authorization,
            CountDownLatch ready,
            CountDownLatch start) throws Exception {
        ready.countDown();
        await(start);
        ResponseEntity<List<PostSummary>> response =
                controller.list(authorization);
        List<PostSummary> body = Objects.requireNonNull(
                response.getBody());
        return body.get(0).memberId();
    }

    private static void await(CountDownLatch latch)
            throws InterruptedException {
        if (!latch.await(1, SECONDS)) {
            throw new IllegalStateException("latch timeout");
        }
    }

    private static void stop(ExecutorService pool)
            throws InterruptedException {
        pool.shutdownNow();
        assertTrue(pool.awaitTermination(1, SECONDS));
    }

    private record Fixture(
            MockMvc mockMvc,
            ObjectMapper objectMapper,
            AtomicInteger queryCalls,
            List<Long> queriedMembers) {
    }

    private static final class StatefulMemberController {
        private long currentMemberId;

        void select(long memberId) {
            currentMemberId = memberId;
        }

        long current() {
            return currentMemberId;
        }
    }
}