거래 스레드의 토큰 발급을 이력에 TRANSACTION 으로 구분

토큰이 없거나 만료되어 거래 중 발급한 경우도 SCHEDULE 로 기록되던 문제 수정

src/main/java/com/eactive/eai/common/authoutbound/AccessTokenManagerByDB.java

@@ -258,7 +258,7 @@ public class AccessTokenManagerByDB implements Lifecycle {
 					if (cached == null) {
 						logger.debug("Token not exists for adapter group: {}", adapterGroupName);
 						sessionManager.getOutboundAccessToken(adapterGroupName,
-								token -> issueToken(credential));
+								token -> issueToken(credential, TokenIssueHistory.TRIGGER_SCHEDULE));
 
 					} else if (cached.getExpiration() == null) {
 						// 만료시각이 없는 토큰은 갱신 시점을 판단할 수 없다.
@@ -272,7 +272,7 @@ public class AccessTokenManagerByDB implements Lifecycle {
 						logger.debug("Token expires before next schedule : {}, expiration date: {}",
 								adapterGroupName, cached.getExpiration());
 						sessionManager.reissueOutboundAccessToken(adapterGroupName, cached.getAccessToken(),
-								intervalTime, token -> issueToken(credential));
+								intervalTime, token -> issueToken(credential, TokenIssueHistory.TRIGGER_SCHEDULE));
 
 					} else {
 						logger.debug(
@@ -300,7 +300,10 @@ public class AccessTokenManagerByDB implements Lifecycle {
 		}
 	}
 
-	private AccessTokenVO issueToken(OutboundOAuthCredentialVo outboundOAuthCredentialVo) {
+	/**
+	 * @param trigger 발급 이력에 남길 호출 경로 (TokenIssueHistory.TRIGGER_*)
+	 */
+	private AccessTokenVO issueToken(OutboundOAuthCredentialVo outboundOAuthCredentialVo, String trigger) {
 	    String adapterGroupName = outboundOAuthCredentialVo.getAdapterGroupName();
 	    AccessTokenVO accessToken = null;
 	    try {
@@ -335,12 +338,12 @@ public class AccessTokenManagerByDB implements Lifecycle {
 						accessToken = (AccessTokenVO) service.execute(adapterGroupName, properties,
 								outboundOAuthCredentialVo);
 					} catch (Exception e) {
-						recordIssueHistory(adapterGroupName, TokenIssueHistory.TRIGGER_SCHEDULE, type, startTime, null,
+						recordIssueHistory(adapterGroupName, trigger, type, startTime, null,
 								toFailReason(e));
 						throw e;
 					}
 
-					recordIssueHistory(adapterGroupName, TokenIssueHistory.TRIGGER_SCHEDULE, type, startTime,
+					recordIssueHistory(adapterGroupName, trigger, type, startTime,
 							accessToken, null);
 
 					// 발급에 실패했는데도 빈 토큰을 반환하는 구현체가 있다. 그대로 캐시되면
@@ -354,12 +357,12 @@ public class AccessTokenManagerByDB implements Lifecycle {
 					return accessToken;
 
 				} else {
-					recordIssueHistory(adapterGroupName, TokenIssueHistory.TRIGGER_SCHEDULE, type,
+					recordIssueHistory(adapterGroupName, trigger, type,
 							System.currentTimeMillis(), null, "토큰 발급 구현체를 찾을 수 없음");
 					logger.warn("Token service not found for type: {} and adapter group: {}", type, adapterGroupName);
 				}
 			} else {
-				recordIssueHistory(adapterGroupName, TokenIssueHistory.TRIGGER_SCHEDULE, null,
+				recordIssueHistory(adapterGroupName, trigger, null,
 						System.currentTimeMillis(), null, "어댑터 설정을 찾을 수 없음");
 				logger.warn("No valid adapter configuration found for adapter group: {}", adapterGroupName);
 			}
@@ -429,7 +432,7 @@ public class AccessTokenManagerByDB implements Lifecycle {
 	 * 3. 주의사항 : accessToken 은 앞 UNMASKED_TOKEN_LENGTH 자만 남겨 보관한다.
 	 *
 	 * @param adapterGroupName 어댑터그룹명
-	 * @param trigger          SCHEDULE / RETRY
+	 * @param trigger          SCHEDULE / RETRY / TRANSACTION
 	 * @param serviceClass     사용한 발급 구현체 클래스명
 	 * @param startTime        발급 시도 시각
 	 * @param accessToken      발급된 토큰. 실패 시 null.
@@ -553,7 +556,8 @@ public class AccessTokenManagerByDB implements Lifecycle {
 			    OutboundOAuthCredentialVo outboundOAuthCredentialVo = outboundOAuthCredentialVos
 				    .get(adapterGroupName);
 
-			    return issueToken(outboundOAuthCredentialVo);
+			    // 스케줄러가 아니라 거래 스레드가 토큰이 없거나 만료된 것을 보고 발급하는 경로다.
+			    return issueToken(outboundOAuthCredentialVo, TokenIssueHistory.TRIGGER_TRANSACTION);
 			}
 		    });
 

src/main/java/com/eactive/eai/common/authoutbound/TokenIssueHistory.java

@@ -17,15 +17,18 @@ public class TokenIssueHistory {
 	/** 스케줄러의 주기 발급 */
 	public static final String TRIGGER_SCHEDULE = "SCHEDULE";
 
-	/** 거래 중 재발급 */
+	/** 거래 중 재발급 (기관이 토큰을 거부한 경우) */
 	public static final String TRIGGER_RETRY = "RETRY";
 
+	/** 거래 중 발급 (캐시에 토큰이 없거나 이미 만료된 경우) */
+	public static final String TRIGGER_TRANSACTION = "TRANSACTION";
+
 	private static final String DATE_FORMAT = "yyyy-MM-dd HH:mm:ss";
 
 	/** 발급을 시도한 시각 */
 	private final String issuedAt;
 
-	/** SCHEDULE | RETRY */
+	/** SCHEDULE | RETRY | TRANSACTION */
 	private final String trigger;
 
 	/** 사용한 발급 구현체 클래스명 */

src/main/java/com/eactive/eai/common/session/SessionManagerForIgnite.java

@@ -77,11 +77,29 @@ import ch.qos.logback.classic.Level;
 public class SessionManagerForIgnite extends SessionManager {
     
 
-	/** 아웃바운드 토큰 분산락 대기 시간(초). 스케줄러 경로에서 사용한다. */
+	/** 아웃바운드 토큰 분산락 대기 시간(ms) 설정 키 (RMIInfo 그룹) */
-	private static final int TOKEN_LOCK_WAIT_SECONDS = 60;
+	public static final String OUTBOUND_TOKEN_LOCK_WAIT_MILLIS = "outboundTokenLockWaitMillis";
+	/** 거래 중 재발급(기관 거부) 분산락 대기 시간(ms) 설정 키 (RMIInfo 그룹) */
+	public static final String OUTBOUND_TOKEN_REISSUE_LOCK_WAIT_MILLIS = "outboundTokenReissueLockWaitMillis";
+	/** 아웃바운드 토큰 primary 읽기 트랜잭션 타임아웃(ms) 설정 키 (RMIInfo 그룹) */
+	public static final String OUTBOUND_TOKEN_READ_TX_TIMEOUT_MILLIS = "outboundTokenReadTxTimeoutMillis";
 
-	/** 거래 중 재발급은 거래 스레드를 잡으므로 스케줄러 경로보다 짧게 기다린다. */
+	/**
-	private static final int REISSUE_LOCK_WAIT_SECONDS = 10;
+	 * 아웃바운드 토큰 분산락 대기 시간(ms). RMIInfo.outboundTokenLockWaitMillis
+	 * 토큰이 없거나 만료일 때 거래 스레드도 여기서 기다리므로 길게 잡지 않는다.
+	 * (스케줄러는 락을 못 잡으면 다른 노드가 발급 중이라는 뜻이라 오래 기다릴 필요가 없다)
+	 */
+	private long tokenLockWaitMillis = 15000L;
+
+	/** 거래 중 재발급(기관 거부) 분산락 대기 시간(ms). RMIInfo.outboundTokenReissueLockWaitMillis */
+	private long reissueLockWaitMillis = 10000L;
+
+	/**
+	 * readFromPrimary 트랜잭션 타임아웃(ms). RMIInfo.outboundTokenReadTxTimeoutMillis
+	 * 비관적 트랜잭션 읽기는 키 락을 잡으므로 다른 노드가 lock(key) 로 발급 중이면 발급이 끝날 때까지 기다린다.
+	 * 타임아웃이 없으면 이 대기는 락 대기 시간(tryLock)의 제한을 받지 않는다.
+	 */
+	private long readTxTimeoutMillis = 3000L;
 	// evictMaster Instance - single socket 관련
 	private static IgniteCache<String, String> evictMasterCache = null;
 	// Socket Session cache 정보
@@ -220,6 +238,15 @@ public class SessionManagerForIgnite extends SessionManager {
 			}
 		}
 
+		tokenLockWaitMillis = parseMillis(prpty, OUTBOUND_TOKEN_LOCK_WAIT_MILLIS, tokenLockWaitMillis, 1000L);
+		reissueLockWaitMillis = parseMillis(prpty, OUTBOUND_TOKEN_REISSUE_LOCK_WAIT_MILLIS, reissueLockWaitMillis, 1000L);
+		readTxTimeoutMillis = parseMillis(prpty, OUTBOUND_TOKEN_READ_TX_TIMEOUT_MILLIS, readTxTimeoutMillis, 100L);
+
+		if (logger.isWarn()) {
+			logger.warn(">> OutboundToken tokenLockWaitMillis = " + tokenLockWaitMillis + ", reissueLockWaitMillis = "
+					+ reissueLockWaitMillis + ", readTxTimeoutMillis = " + readTxTimeoutMillis);
+		}
+		
 		IgniteConfiguration config = new IgniteConfiguration();
 		
 		if(StringUtils.isNotEmpty(workingDirectory)) {
@@ -450,6 +477,27 @@ public class SessionManagerForIgnite extends SessionManager {
 		cacheTerminal = manager.cache(TERMINAL_CAHCE_NAME);		
 	}
 
+	/**
+	 * 밀리초 설정값을 읽는다. 없거나 숫자가 아니거나 최소값보다 작으면 기본값을 쓴다.
+	 */
+	private long parseMillis(Properties prpty, String key, long defaultValue, long minValue) {
+		String value = prpty == null ? null : prpty.getProperty(key);
+		if (StringUtils.isBlank(value)) {
+			return defaultValue;
+		}
+		try {
+			long millis = Long.parseLong(value.trim());
+			if (millis < minValue) {
+				logger.warn(">> " + key + " = " + value + " is less than " + minValue + ". use default " + defaultValue);
+				return defaultValue;
+			}
+			return millis;
+		} catch (NumberFormatException ex) {
+			logger.warn(">> " + key + " = " + value + " is not a number. use default " + defaultValue);
+			return defaultValue;
+		}
+	}
+
 	private CacheConfiguration initCache(IgniteConfiguration config, int expiryDurationSecs,
 		String bootstrapAsynchronously, String name, int maxsize, boolean useCacheWriteModeAsync,
 		boolean transactionMode) {
@@ -848,17 +896,20 @@ public class SessionManagerForIgnite extends SessionManager {
 	 * 비관적 트랜잭션 안에서 읽으면 primary 의 값을 보장받는다. 트랜잭션은 읽기 직후 바로 닫는다.
 	 * (발급 HTTP 호출 구간까지 열어두면 장기 트랜잭션이 되어 파티션 맵 교환을 막는다)
 	 *
+	 * 다른 노드가 발급 중이라 키 락을 기다리게 되면 readTxTimeoutMillis 후 포기하고 일반 get() 으로 읽는다.
+	 *
 	 * @param key 어댑터그룹명
 	 * @return 캐시에 있는 토큰. 없으면 null.
 	 */
 	private AccessTokenVO readFromPrimary(String key) {
 		try (Transaction tx = manager.transactions().txStart(TransactionConcurrency.PESSIMISTIC,
-				TransactionIsolation.REPEATABLE_READ)) {
+				TransactionIsolation.REPEATABLE_READ, readTxTimeoutMillis, 1)) {
 			AccessTokenVO token = cacheOutBoundAccessToken.get(key);
 			tx.commit();
 			return token;
 		} catch (Throwable e) {
-			logger.error("occuring exception in readFromPrimary. key=" + key, e);
+			// 다른 노드가 발급 중이라 트랜잭션 타임아웃으로 빠지는 것은 예상된 경우라 WARN 으로 남긴다.
+			logger.warn("occuring exception in readFromPrimary. fallback to get(). key=" + key, e);
 			return cacheOutBoundAccessToken.get(key);
 		}
 	}
@@ -907,7 +958,7 @@ public class SessionManagerForIgnite extends SessionManager {
 		boolean acquired = false;
 
 		try {
-			acquired = lock.tryLock(REISSUE_LOCK_WAIT_SECONDS, TimeUnit.SECONDS);
+			acquired = lock.tryLock(reissueLockWaitMillis, TimeUnit.MILLISECONDS);
 
 			if (!acquired) {
 				logger.warn("reissueOutboundAccessToken lock timeout. key=" + key);
@@ -1039,12 +1090,13 @@ public class SessionManagerForIgnite extends SessionManager {
 	        
 	        try {
 	            logger.debug("calling func getOutboundAccessToken = distributed ignite trylock");
-	            acquired = lock.tryLock(TOKEN_LOCK_WAIT_SECONDS, TimeUnit.SECONDS);
+	            acquired = lock.tryLock(tokenLockWaitMillis, TimeUnit.MILLISECONDS);
 	            
 	            if ( acquired ) {
 	        	logger.debug("calling func getOutboundAccessToken = distributed ignite trylock success=>"+acquired);
 			// 3. 락 획득 후 다시 확인 (그 사이 다른 인스턴스가 갱신했을 수 있음)
-			token = cacheOutBoundAccessToken.get(key);
+			// near 캐시 사본은 무효화가 늦을 수 있어 get() 으로는 방금 발급된 토큰을 놓치고 다시 발급할 수 있다.
+			token = readFromPrimary(key);
 
 			logger.debug(String.format("getting token in ignite=%s", token));
 
@@ -1094,7 +1146,7 @@ public class SessionManagerForIgnite extends SessionManager {
 	    try {
 		
 		logger.debug("calling func removeOutboundAccessToken = distributed ignite trylock");
-		acquired = lock.tryLock(TOKEN_LOCK_WAIT_SECONDS, TimeUnit.SECONDS);
+		acquired = lock.tryLock(tokenLockWaitMillis, TimeUnit.MILLISECONDS);
 		
 		if( acquired ) {
 		    if (logger.isDebug()) {

src/main/java/com/eactive/eai/manage/oauthtoken/OAuthTokenStatusDTO.java

@@ -90,10 +90,10 @@ public class OAuthTokenStatusDTO {
 	String serverName;
 
 	/**
-	 * 토큰 발급 이력 (최근 순, 최대 10건).
+	 * 토큰 발급 이력 (최근 순).
 	 *
 	 * 이 노드에서 일어난 발급만 담기며 재기동 시 사라진다.
-	 * 목록 조회에는 담지 않고 어댑터그룹 단건 조회에서만 채운다.
+	 * 단건 조회는 보관 중인 전체(최대 10건), 목록 조회는 최근 1건만 담는다.
 	 */
 	List<TokenIssueHistory> issueHistory;
 }

src/main/java/com/eactive/eai/manage/oauthtoken/OAuthTokenStatusService.java

@@ -19,6 +19,7 @@ import com.eactive.eai.adapter.AdapterPropManager;
 import com.eactive.eai.adapter.AdapterVO;
 import com.eactive.eai.authoutbound.OutboundOAuthCredentialVo;
 import com.eactive.eai.common.authoutbound.AccessTokenManagerByDB;
+import com.eactive.eai.common.authoutbound.TokenIssueHistory;
 import com.eactive.eai.common.server.EAIServerManager;
 import com.eactive.eai.common.util.Logger;
 import com.openbanking.eai.common.token.AccessTokenVO;
@@ -45,6 +46,9 @@ public class OAuthTokenStatusService {
 	/** accessToken 중 노출할 앞자리 수 */
 	private static final int UNMASKED_LENGTH = 8;
 
+	/** 목록 조회에 담을 발급 이력 건수 */
+	private static final int LIST_HISTORY_SIZE = 1;
+
 	/**
 	 * 등록된 모든 어댑터그룹의 토큰 현황을 반환한다.
 	 *
@@ -53,39 +57,38 @@ public class OAuthTokenStatusService {
 	public List<OAuthTokenStatusDTO> getStatusList() {
 		List<OAuthTokenStatusDTO> result = new ArrayList<OAuthTokenStatusDTO>();
 		for (String adapterGroupName : AccessTokenManagerByDB.getInstance().getRegisteredAdapterGroupNames()) {
-			// 목록에는 발급 이력을 담지 않는다. 그룹이 많으면 응답이 지나치게 커진다.
+			// 목록에는 최근 1건만 담는다. 전체를 담으면 그룹 수만큼 응답이 커진다.
-			result.add(getStatus(adapterGroupName, false));
+			result.add(getStatus(adapterGroupName, LIST_HISTORY_SIZE));
 		}
 		return result;
 	}
 
 	/**
-	 * 어댑터그룹 하나의 토큰 현황을 발급 이력과 함께 반환한다.
+	 * 어댑터그룹 하나의 토큰 현황을 발급 이력 전체와 함께 반환한다.
 	 *
 	 * @param adapterGroupName 어댑터그룹명
 	 * @return 토큰 현황. 등록돼 있지 않으면 message 만 채워서 반환한다.
 	 */
 	public OAuthTokenStatusDTO getStatus(String adapterGroupName) {
-		return getStatus(adapterGroupName, true);
+		return getStatus(adapterGroupName, Integer.MAX_VALUE);
 	}
 
 	/**
 	 * 어댑터그룹 하나의 토큰 현황을 반환한다.
 	 *
 	 * @param adapterGroupName 어댑터그룹명
-	 * @param includeHistory   토큰 발급 이력 포함 여부
+	 * @param historyLimit     담을 발급 이력 건수 (최근 순)
 	 * @return 토큰 현황. 등록돼 있지 않으면 message 만 채워서 반환한다.
 	 */
-	private OAuthTokenStatusDTO getStatus(String adapterGroupName, boolean includeHistory) {
+	private OAuthTokenStatusDTO getStatus(String adapterGroupName, int historyLimit) {
 		OAuthTokenStatusDTO dto = new OAuthTokenStatusDTO();
 		dto.setAdapterGroupName(adapterGroupName);
 
 		AccessTokenManagerByDB manager = AccessTokenManagerByDB.getInstance();
 
-		if (includeHistory) {
+		// 이력은 노드 로컬이므로 어느 노드가 응답했는지 함께 담는다.
 		dto.setServerName(findLocalServerName());
-			dto.setIssueHistory(manager.getIssueHistories(adapterGroupName));
+		dto.setIssueHistory(latest(manager.getIssueHistories(adapterGroupName), historyLimit));
-		}
 		OutboundOAuthCredentialVo credential = manager.getOutboundOAuthCredentialVo(adapterGroupName);
 
 		if (credential == null) {
@@ -175,6 +178,20 @@ public class OAuthTokenStatusService {
 		return dto;
 	}
 
+	/**
+	 * 발급 이력에서 최근 건만 잘라낸다. 이력은 이미 최근 순으로 정렬돼 있다.
+	 *
+	 * @param histories 발급 이력
+	 * @param limit     담을 건수
+	 * @return 최근 limit 건
+	 */
+	private List<TokenIssueHistory> latest(List<TokenIssueHistory> histories, int limit) {
+		if (histories.size() <= limit) {
+			return histories;
+		}
+		return new ArrayList<TokenIssueHistory>(histories.subList(0, limit));
+	}
+
 	/**
 	 * 이 응답을 만든 서버명을 찾는다. 발급 이력이 노드 로컬이라 함께 알려준다.
 	 *

src/test/java/com/eactive/eai/common/session/SessionManagerForIgniteReissueTest.java

@@ -58,6 +58,9 @@ class SessionManagerForIgniteReissueTest {
     /** readFromPrimary 가 여는 트랜잭션 */
     private Transaction transaction;
 
+    /** readFromPrimary 가 트랜잭션을 여는 곳 (타임아웃 인자 검증용) */
+    private IgniteTransactions transactions;
+
     @BeforeEach
     void setUp() throws Exception {
         sessionManager = new SessionManagerForIgnite();
@@ -86,9 +89,9 @@ class SessionManagerForIgniteReissueTest {
      */
     private void injectIgnite() throws Exception {
         transaction = Mockito.mock(Transaction.class);
-        IgniteTransactions transactions = Mockito.mock(IgniteTransactions.class);
+        transactions = Mockito.mock(IgniteTransactions.class);
-        Mockito.when(transactions.txStart(any(TransactionConcurrency.class), any(TransactionIsolation.class)))
+        Mockito.when(transactions.txStart(any(TransactionConcurrency.class), any(TransactionIsolation.class),
-                .thenReturn(transaction);
+                Mockito.anyLong(), Mockito.anyInt())).thenReturn(transaction);
 
         Ignite ignite = Mockito.mock(Ignite.class);
         Mockito.when(ignite.transactions()).thenReturn(transactions);
@@ -316,4 +319,48 @@ class SessionManagerForIgniteReissueTest {
         assertTrue(locks.containsKey("GRP-A") && locks.containsKey("GRP-B"), "그룹별로 락이 분리돼야 한다");
         assertSame(locks.get("GRP-A"), locks.get("GRP-A"));
     }
+
+    @Test
+    @DisplayName("8. 트랜잭션 읽기에는 타임아웃을 준다 (발급 중인 노드의 락을 무한정 기다리지 않도록)")
+    void 트랜잭션읽기_타임아웃() {
+        store.put(GROUP, token("OLD"));
+
+        sessionManager.reissueOutboundAccessToken(GROUP, "OLD", 0L, supplier(new AtomicInteger(), "NEW"));
+
+        Mockito.verify(transactions, Mockito.times(2)).txStart(
+                Mockito.eq(TransactionConcurrency.PESSIMISTIC), Mockito.eq(TransactionIsolation.REPEATABLE_READ),
+                Mockito.longThat(timeout -> timeout > 0), Mockito.anyInt());
+    }
+
+    @Test
+    @DisplayName("9. getOutboundAccessToken 도 락 안의 재확인은 트랜잭션으로 읽는다")
+    void 최초발급_락안에서_트랜잭션읽기() {
+        AtomicInteger issued = new AtomicInteger();
+
+        AccessTokenVO result = sessionManager.getOutboundAccessToken(GROUP, supplier(issued, "NEW"));
+
+        assertEquals(1, issued.get());
+        assertEquals("NEW", result.getAccessToken());
+        Mockito.verify(transaction, Mockito.times(1)).commit();
+    }
+
+    @Test
+    @DisplayName("10. getOutboundAccessToken - 락 안에서 읽은 토큰이 유효하면 발급하지 않는다")
+    void 최초발급_락안에서_이미발급됨() {
+        // 락 밖 get() 은 옛 만료 토큰(near 캐시 사본), 락 안의 트랜잭션 읽기는 다른 노드가 방금 넣은 토큰을 돌려준다.
+        OAuth2AccessTokenVO expired = token("OLD");
+        expired.setExpiration(new Date(System.currentTimeMillis() - 1_000L));
+        store.put(GROUP, expired);
+        Mockito.when(transactions.txStart(any(TransactionConcurrency.class), any(TransactionIsolation.class),
+                Mockito.anyLong(), Mockito.anyInt())).thenAnswer(invocation -> {
+                    store.put(GROUP, token("ALREADY-NEW"));
+                    return transaction;
+                });
+
+        AtomicInteger issued = new AtomicInteger();
+        AccessTokenVO result = sessionManager.getOutboundAccessToken(GROUP, supplier(issued, "NEW"));
+
+        assertEquals(0, issued.get(), "락 안에서 확인한 토큰이 유효하면 발급하지 않아야 한다");
+        assertEquals("ALREADY-NEW", result.getAccessToken());
+    }
 }

src/test/java/com/eactive/eai/manage/oauthtoken/OAuthTokenStatusServiceTest.java

@@ -8,6 +8,7 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.ArgumentMatchers.anyString;
 
 import java.lang.reflect.Field;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Date;
@@ -23,6 +24,7 @@ import org.springframework.context.ApplicationContext;
 
 import com.eactive.eai.authoutbound.OutboundOAuthCredentialVo;
 import com.eactive.eai.common.authoutbound.AccessTokenManagerByDB;
+import com.eactive.eai.common.authoutbound.TokenIssueHistory;
 import com.eactive.eai.common.util.ApplicationContextProvider;
 import com.openbanking.eai.common.token.OAuth2AccessTokenVO;
 
@@ -64,6 +66,21 @@ class OAuthTokenStatusServiceTest {
         return credential;
     }
 
+    /**
+     * 최근 순으로 정렬된 발급 이력 count 건 (svc-0 이 최신).
+     *
+     * TokenIssueHistory 생성자는 package-private 이라 mock 으로 만든다.
+     */
+    private List<TokenIssueHistory> histories(int count) {
+        List<TokenIssueHistory> result = new ArrayList<>();
+        for (int i = 0; i < count; i++) {
+            TokenIssueHistory history = Mockito.mock(TokenIssueHistory.class);
+            Mockito.when(history.getServiceClass()).thenReturn("svc-" + i);
+            result.add(history);
+        }
+        return result;
+    }
+
     /** 만료까지 expiresInSec 남은 토큰 */
     private OAuth2AccessTokenVO token(String accessToken, long expiresInSec) {
         OAuth2AccessTokenVO vo = new OAuth2AccessTokenVO();
@@ -277,20 +294,35 @@ class OAuthTokenStatusServiceTest {
     }
 
     @Test
-    @DisplayName("9-1. 단건 조회에는 발급 이력을 담고 목록에는 담지 않는다")
+    @DisplayName("9-1. 단건 조회는 이력 전체, 목록은 최근 1건만 담는다")
     void 이력포함범위() {
         Set<String> groups = new LinkedHashSet<>(Arrays.asList(GROUP));
         Mockito.when(mockManager.getRegisteredAdapterGroupNames()).thenReturn(groups);
         registerCredential(GROUP);
         Mockito.when(mockManager.peekAccessTokenVO(GROUP)).thenReturn(token("abcdefghijkl", 600));
-        Mockito.when(mockManager.getIssueHistories(GROUP)).thenReturn(Collections.emptyList());
+        // histories() 안에서 mock 을 만들므로 when(...) 인자에 직접 넣으면 스터빙이 중첩된다.
+        List<TokenIssueHistory> histories = histories(3);
+        Mockito.when(mockManager.getIssueHistories(GROUP)).thenReturn(histories);
 
         OAuthTokenStatusDTO single = service.getStatus(GROUP);
         OAuthTokenStatusDTO fromList = service.getStatusList().get(0);
 
-        assertNotNull(single.getIssueHistory(), "단건 조회에는 이력이 있어야 한다");
+        assertEquals(3, single.getIssueHistory().size(), "단건 조회는 보관 중인 이력 전체");
-        assertNull(fromList.getIssueHistory(), "목록에는 이력을 담지 않는다");
+        assertEquals(1, fromList.getIssueHistory().size(), "목록은 최근 1건만");
-        Mockito.verify(mockManager, Mockito.times(1)).getIssueHistories(GROUP);
+        assertEquals("svc-0", fromList.getIssueHistory().get(0).getServiceClass(), "최신 건이어야 한다");
+    }
+
+    @Test
+    @DisplayName("9-2. 이력이 없으면 빈 목록 (null 아님)")
+    void 이력없으면_빈목록() {
+        registerCredential(GROUP);
+        Mockito.when(mockManager.peekAccessTokenVO(GROUP)).thenReturn(token("abcdefghijkl", 600));
+        Mockito.when(mockManager.getIssueHistories(GROUP)).thenReturn(Collections.emptyList());
+
+        OAuthTokenStatusDTO dto = service.getStatus(GROUP);
+
+        assertNotNull(dto.getIssueHistory());
+        assertTrue(dto.getIssueHistory().isEmpty());
     }
 
     @Test