feat: EncFieldCryptoFilter 추가 및 DJErp 어댑터 암호화 모듈 연동

- EncFieldCryptoFilter 추가: /encryptedData 경로 고정 CryptoFilter 구현체
  (CryptoAdapterFilter 대체, custom 패키지로 분리)
- DJErpApiAdapterService: CRYPTO_MODULE_NAME 프로퍼티 transactionProp에 전달
- elink-online-common 서브모듈 업데이트
  (CryptoFilter UPPER_UNDERSCORE 키, HSM 통합 테스트 포함)
- elink-online-transformer 서브모듈 업데이트

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

WebContent/WEB-INF/authserver-servlet.xml

@@ -25,6 +25,9 @@
 		base-package="com.eactive.eai.adapter" />
 	<context:component-scan
 		base-package="com.eactive.eai.manage" />
+	<context:component-scan
+		base-package="com.eactive.eai.custom.inflow" />
+	
 	<context:annotation-config />
 	<mvc:annotation-driven />
 	<mvc:default-servlet-handler />

WebContent/WEB-INF/web.xml

@@ -19,6 +19,7 @@
         <url-pattern>/agent/*</url-pattern>
         <url-pattern>/common/*</url-pattern>
         <url-pattern>/management/*</url-pattern>
+        <url-pattern>/manage/*</url-pattern>
         <url-pattern>/mgr/*</url-pattern>        
     </filter-mapping>
 

src/main/java/com/eactive/eai/adapter/service/DJErpApiAdapterService.java

@@ -7,6 +7,7 @@ import com.eactive.eai.adapter.Keys;
 import com.eactive.eai.adapter.http.HttpMemoryLogger;
 import com.eactive.eai.adapter.http.HttpMethodType;
 import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceSupport;
+import com.eactive.eai.adapter.http.dynamic.filter.CryptoFilter;
 import com.eactive.eai.adapter.http.dynamic.filter.JwtAuthFilter;
 import com.eactive.eai.common.exception.ExceptionUtil;
 import com.eactive.eai.common.message.MessageType;
@@ -142,7 +143,8 @@ public class DJErpApiAdapterService extends HttpAdapterServiceSupport {
         transactionProp.put(INBOUND_TOKEN, inboundToken);
         transactionProp.put(ENCRYPT_AES256_IV, httpProp.getProperty(ENCRYPT_AES256_IV, ""));  //jwhong
         transactionProp.put(ENCRYPT_AES256_KEY, httpProp.getProperty(ENCRYPT_AES256_KEY, ""));  //jwhong
-      
+        
+        transactionProp.put(CryptoFilter.PROP_MODULE_NAME, httpProp.getProperty(CryptoFilter.PROP_MODULE_NAME, ""));
         
         // SEED 컬럼암호하 시  Key로 사용함
         String seedkey = getHeaders(request).getOrDefault("x-obp-partnercode", "").toString();

src/main/java/com/eactive/eai/custom/adapter/http/dynamic/filter/DJBErpCryptoFilter.java

@@ -0,0 +1,82 @@
+package com.eactive.eai.custom.adapter.http.dynamic.filter;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Properties;
+
+import javax.servlet.http.HttpServletRequest;
+
+import org.apache.commons.lang3.StringUtils;
+
+import com.eactive.eai.adapter.http.dynamic.filter.CryptoFilter;
+import com.eactive.eai.util.JsonPathUtil;
+
+/**
+ * DJB ERP 연동용 암복호화 필터.
+ *
+ * DYNAMIC 키 컨텍스트 추출 규칙:
+ *   HTTP 헤더 {@code httpHeaderGroup}의 값은 JSON 객체이며,
+ *   그 중 {@code x-emp-nm} 필드 값을 {@code groupSeq}로
+ *   runtimeContext에 담아 키 도출 전략에 전달한다.
+ *
+ * 어댑터 프로퍼티 (부모 클래스 공통 설정 외 추가 키):
+ *   crypto.context.key          runtimeContext에 넣을 키 이름 (기본: groupSeq)
+ *   crypto.context.header       컨텍스트 JSON이 담긴 HTTP 헤더명 (기본: httpHeaderGroup)
+ *   crypto.context.header.field 헤더 JSON에서 추출할 필드명 (기본: x-emp-nm)
+ *
+ * 어댑터 프로퍼티 설정 예:
+ *   crypto.module.name          = AES_GCM_NoPadding_DYNAMIC_sample
+ *   crypto.scope                = FIELD
+ *   crypto.dec.enabled          = Y
+ *   crypto.enc.enabled          = N
+ *   crypto.dec.from.path        = /encryptedData
+ *   crypto.dec.to.path          = /
+ *   crypto.context.key          = groupSeq
+ *   crypto.context.header       = httpHeaderGroup
+ *   crypto.context.header.field = x-emp-nm
+ *
+ * 필터 타입 등록 (FQCN):
+ *   com.eactive.eai.custom.adapter.http.dynamic.filter.DJBErpCryptoFilter
+ */
+public class DJBErpCryptoFilter extends CryptoFilter {
+
+    public static final String PROP_CONTEXT_KEY          = "crypto.context.key";
+    public static final String PROP_CONTEXT_HEADER       = "crypto.context.header";
+    public static final String PROP_CONTEXT_HEADER_FIELD = "crypto.context.header.field";
+
+    private static final String DEFAULT_CONTEXT_KEY          = "groupSeq";
+    private static final String DEFAULT_CONTEXT_HEADER       = "httpHeaderGroup";
+    private static final String DEFAULT_CONTEXT_HEADER_FIELD = "x-emp-nm";
+
+    /**
+     * httpHeaderGroup 헤더(JSON)에서 x-emp-nm 값을 추출하여 groupSeq로 매핑한다.
+     * 헤더가 없거나 필드를 찾을 수 없으면 빈 Map을 반환한다.
+     */
+    @Override
+    protected Map<String, String> buildRuntimeContext(Properties prop, HttpServletRequest request) {
+        Map<String, String> ctx = new HashMap<>();
+
+        String contextKey         = prop.getProperty(PROP_CONTEXT_KEY,          DEFAULT_CONTEXT_KEY);
+        String contextHeaderName  = prop.getProperty(PROP_CONTEXT_HEADER,       DEFAULT_CONTEXT_HEADER);
+        String contextHeaderField = prop.getProperty(PROP_CONTEXT_HEADER_FIELD, DEFAULT_CONTEXT_HEADER_FIELD);
+
+        String headerJson = request.getHeader(contextHeaderName);
+        if (StringUtils.isBlank(headerJson)) {
+            logger.warn("DJBErpCryptoFilter] 컨텍스트 헤더 없음: " + contextHeaderName);
+            return ctx;
+        }
+
+        String value = JsonPathUtil.getValueAtPath(headerJson, "/" + contextHeaderField);
+        if (value == null) {
+            logger.warn("DJBErpCryptoFilter] 헤더 JSON에서 필드 추출 실패: header="
+                    + contextHeaderName + ", field=" + contextHeaderField);
+            return ctx;
+        }
+
+        // x-emp-nm 값은 "groupSeq|empNo" 형태 — '|' 앞부분만 groupSeq로 사용
+        String groupSeq = value.contains("|") ? value.substring(0, value.indexOf('|')) : value;
+        ctx.put(contextKey, groupSeq);
+
+        return ctx;
+    }
+}

src/main/java/com/eactive/eai/custom/adapter/http/dynamic/filter/EncFieldCryptoFilter.java

@@ -0,0 +1,40 @@
+package com.eactive.eai.custom.adapter.http.dynamic.filter;
+
+import java.util.Properties;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import com.eactive.eai.adapter.http.dynamic.filter.BaseCryptoFilter;
+import com.eactive.eai.adapter.http.dynamic.filter.HttpAdapterFilter;
+
+/**
+ * CryptoFilter 프로퍼티를 멤버변수로 관리하는 HttpAdapterFilter 구현체.
+ *
+ * 멤버변수에 세팅된 값을 Properties로 변환하여 {@link BaseCryptoFilter}에 위임한다.
+ * 값이 blank인 멤버변수는 Properties에 포함하지 않으며, CryptoFilter의 기본값이 적용된다.
+ */
+public class EncFieldCryptoFilter implements HttpAdapterFilter {
+
+    private final BaseCryptoFilter filter = new BaseCryptoFilter();
+
+    @Override
+    public Object doPreFilter(String adptGrpName, String adptName, Object message, Properties prop,
+            HttpServletRequest request, HttpServletResponse response) throws Exception {
+        return filter.doPreFilter(adptGrpName, adptName, message, setProp(prop), request, response);
+    }
+
+    @Override
+    public Object doPostFilter(String adptGrpName, String adptName, Object resultMessage, Properties prop,
+            HttpServletRequest request, HttpServletResponse response) throws Exception {
+        return filter.doPostFilter(adptGrpName, adptName, resultMessage, setProp(prop), request, response);
+    }
+
+    private Properties setProp(Properties p) {
+    	p.setProperty(BaseCryptoFilter.PROP_DEC_FROM_PATH, "/encryptedData");
+    	p.setProperty(BaseCryptoFilter.PROP_ENC_TO_PATH, "/encryptedData");
+        return p;
+    }
+
+    
+}

src/main/java/com/eactive/eai/custom/inbound/processor/DJBRequestProcessor.java

@@ -0,0 +1,81 @@
+package com.eactive.eai.custom.inbound.processor;
+
+import org.apache.commons.lang3.StringUtils;
+
+import com.eactive.eai.common.inflow.Bucket;
+import com.eactive.eai.common.inflow.InflowTargetVO;
+import com.eactive.eai.common.inflow.dual.ClientDualBucket;
+import com.eactive.eai.common.inflow.dual.DualBucket;
+import com.eactive.eai.common.inflow.dual.DualCustomBucket;
+import com.eactive.eai.inbound.processor.RequestProcessor;
+
+/**
+ * 어댑터/인터페이스/클라이언트 유량제어 차단 시 어느 버킷(PER_SECOND/THRESHOLD)에서
+ * 차단됐는지 에러 메시지에 포함하는 RequestProcessor 확장.
+ *
+ * <p>ClientDualInflowControlManager와 함께 사용:
+ * <pre>
+ * inflow.control.bucket.className=com.eactive.eai.common.inflow.dual.ClientDualInflowControlManager
+ * </pre>
+ *
+ * <p>Spring Bean 등록 후 기존 RequestProcessor 대신 이 클래스를 어댑터에 설정한다.
+ */
+public class DJBRequestProcessor extends RequestProcessor {
+
+    @Override
+    protected String checkClientInflow(Bucket bucket, String clientId) {
+        if (StringUtils.isBlank(clientId)) return null;
+        if (bucket instanceof ClientDualBucket) {
+            return ((ClientDualBucket) bucket).isClientPassDetail(clientId);
+        }
+        return null;
+    }
+
+    @Override
+    protected InflowTargetVO resolveClientInflowThreshold(Bucket bucket, String clientId) {
+        if (bucket instanceof ClientDualBucket) {
+            return ((ClientDualBucket) bucket).getClientInflowThreshold(clientId);
+        }
+        return null;
+    }
+
+    @Override
+    protected String checkAdapterInflow(Bucket bucket, String adapterGroupName) {
+        if (bucket instanceof DualBucket) {
+            return ((DualBucket) bucket).isAdapterPassDetail(adapterGroupName);
+        }
+        return super.checkAdapterInflow(bucket, adapterGroupName);
+    }
+
+    @Override
+    protected String checkInterfaceInflow(Bucket bucket, String eaiSvcCd) {
+        if (bucket instanceof DualBucket) {
+            return ((DualBucket) bucket).isInterfacePassDetail(eaiSvcCd);
+        }
+        return super.checkInterfaceInflow(bucket, eaiSvcCd);
+    }
+
+    /**
+     * 차단 원인에 따라 에러 메시지에 한도 정보를 포함.
+     * <ul>
+     *   <li>PER_SECOND: "API 호출 한도 초과 [name: Nreq/sec]"</li>
+     *   <li>THRESHOLD:  "API 호출 한도 초과 [name: Nreq/UNIT]"</li>
+     *   <li>그 외:      "API 호출 한도 초과 [name]" (기존 동작)</li>
+     * </ul>
+     */
+    @Override
+    protected String buildInflowTargetErrorMsg(InflowTargetVO inflowTargetVO, String blockedType) {
+        if (DualCustomBucket.RESULT_BLOCKED_PER_SECOND.equals(blockedType)) {
+            return String.format("API 호출 한도 초과 [%s: %dreq/sec]",
+                    inflowTargetVO.getName(),
+                    inflowTargetVO.getThresholdPerSecond());
+        }
+        if (DualCustomBucket.RESULT_BLOCKED_THRESHOLD.equals(blockedType)) {
+            return String.format("API 호출 한도 초과 [%s: %dreq/%s]",
+                    inflowTargetVO.getName(),
+                    inflowTargetVO.getThreshold(),
+                    inflowTargetVO.getThresholdTimeUnit());
+        }
+        return super.buildInflowTargetErrorMsg(inflowTargetVO, blockedType);
+    }
+}

src/main/java/com/eactive/eai/custom/inflow/ClientInflowTargetBucketController.java

@@ -0,0 +1,63 @@
+package com.eactive.eai.custom.inflow;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import com.eactive.eai.manage.inflow.TargetBucketStatusDTO;
+
+/**
+ * 클라이언트 버킷 상태 모니터링 API.
+ *
+ * ClientDualInflowControlManager 가 활성화된 환경에서만 정상 응답한다.
+ *
+ * GET /manage/inflow/client/bucket-status             → 전체 클라이언트 버킷 상태
+ * GET /manage/inflow/client/{clientId}/bucket-status  → 특정 클라이언트 버킷 상태
+ */
+@RestController
+@RequestMapping("/manage/inflow")
+public class ClientInflowTargetBucketController {
+
+    @Autowired
+    private ClientInflowTargetBucketService bucketService;
+
+    @GetMapping("/client/bucket-status")
+    public ResponseEntity<?> getAllClientBucketStatus() {
+        List<TargetBucketStatusDTO> list = bucketService.getAllClientBucketStatus();
+        return ok(list);
+    }
+
+    @GetMapping("/client/{clientId}/bucket-status")
+    public ResponseEntity<?> getClientBucketStatus(@PathVariable String clientId) {
+        TargetBucketStatusDTO dto = bucketService.getClientBucketStatus(clientId);
+        return single(dto, "클라이언트를 찾을 수 없습니다: " + clientId);
+    }
+
+    private ResponseEntity<?> ok(List<TargetBucketStatusDTO> list) {
+        Map<String, Object> result = new HashMap<>();
+        result.put("success", true);
+        result.put("data", list);
+        result.put("count", list.size());
+        return ResponseEntity.ok(result);
+    }
+
+    private ResponseEntity<?> single(TargetBucketStatusDTO dto, String notFoundMsg) {
+        if (dto == null) {
+            Map<String, Object> error = new HashMap<>();
+            error.put("success", false);
+            error.put("message", notFoundMsg);
+            return ResponseEntity.ok(error);
+        }
+        Map<String, Object> result = new HashMap<>();
+        result.put("success", true);
+        result.put("data", dto);
+        return ResponseEntity.ok(result);
+    }
+}

src/main/java/com/eactive/eai/custom/inflow/ClientInflowTargetBucketService.java

@@ -0,0 +1,79 @@
+package com.eactive.eai.custom.inflow;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import org.springframework.stereotype.Service;
+
+import com.eactive.eai.common.inflow.AbstractInflowControlManager;
+import com.eactive.eai.common.inflow.InflowControlUtil;
+import com.eactive.eai.common.inflow.InflowTargetVO;
+import com.eactive.eai.common.inflow.dual.ClientDualInflowControlManager;
+import com.eactive.eai.common.inflow.dual.DualCustomBucket;
+import com.eactive.eai.manage.inflow.GroupBucketStatusDTO;
+import com.eactive.eai.manage.inflow.TargetBucketStatusDTO;
+
+/**
+ * 클라이언트 버킷 상태 조회 서비스.
+ *
+ * ClientDualInflowControlManager 가 활성화된 경우에만 동작한다.
+ */
+@Service
+public class ClientInflowTargetBucketService {
+
+    public TargetBucketStatusDTO getClientBucketStatus(String clientId) {
+        ClientDualInflowControlManager manager = getClientDualManager();
+        if (manager == null) return null;
+        DualCustomBucket bucket = manager.getClientBucket(clientId);
+        if (bucket == null) return null;
+        return toDto(clientId, "CLIENT", bucket);
+    }
+
+    public List<TargetBucketStatusDTO> getAllClientBucketStatus() {
+        ClientDualInflowControlManager manager = getClientDualManager();
+        if (manager == null) return new ArrayList<>();
+        return toDtoList("CLIENT", manager.getClientBucketMap());
+    }
+
+    protected ClientDualInflowControlManager getClientDualManager() {
+        AbstractInflowControlManager base = InflowControlUtil.getInflowControlManager();
+        return (base instanceof ClientDualInflowControlManager) ? (ClientDualInflowControlManager) base : null;
+    }
+
+    private TargetBucketStatusDTO toDto(String targetId, String targetType, DualCustomBucket bucket) {
+        InflowTargetVO vo = bucket.getInflowTargetVo();
+        List<GroupBucketStatusDTO.BucketInfo> buckets = new ArrayList<>();
+
+        if (vo.getThresholdPerSecond() > 0) {
+            long capacity  = vo.getThresholdPerSecond();
+            long available = bucket.getPerSecondAvailableTokens();
+            if (available < 0) available = capacity;
+            buckets.add(new GroupBucketStatusDTO.BucketInfo(
+                    "perSecond", capacity, Math.min(available, capacity), "SEC"));
+        }
+
+        if (vo.getThreshold() > 0) {
+            long capacity  = vo.getThreshold();
+            long available = bucket.getThresholdAvailableTokens();
+            if (available < 0) available = capacity;
+            buckets.add(new GroupBucketStatusDTO.BucketInfo(
+                    "threshold", capacity, Math.min(available, capacity), vo.getThresholdTimeUnit()));
+        }
+
+        TargetBucketStatusDTO dto = new TargetBucketStatusDTO();
+        dto.setTargetId(targetId);
+        dto.setTargetType(targetType);
+        dto.setActivate(vo.isActivate());
+        dto.setBuckets(buckets);
+        return dto;
+    }
+
+    private List<TargetBucketStatusDTO> toDtoList(String targetType, Map<String, DualCustomBucket> bucketMap) {
+        List<TargetBucketStatusDTO> result = new ArrayList<>();
+        for (Map.Entry<String, DualCustomBucket> entry : bucketMap.entrySet()) {
+            result.add(toDto(entry.getKey(), targetType, entry.getValue()));
+        }
+        return result;
+    }
+}

src/main/java/com/eactive/eai/custom/inflow/ClientInflowTargetMetricController.java

@@ -0,0 +1,94 @@
+package com.eactive.eai.custom.inflow;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import com.eactive.eai.manage.inflow.TargetMetricDTO;
+
+/**
+ * 클라이언트 유량제어 메트릭 API.
+ *
+ * ClientDualInflowControlManager 가 활성화된 환경에서만 정상 응답한다.
+ *
+ * GET  /manage/inflow/client/metric                       → 전체 클라이언트 메트릭
+ * GET  /manage/inflow/client/{clientId}/metric            → 특정 클라이언트 메트릭
+ * POST /manage/inflow/client/metric/reset                 → 전체 클라이언트 메트릭 초기화
+ * POST /manage/inflow/client/{clientId}/metric/reset      → 특정 클라이언트 메트릭 초기화
+ */
+@RestController
+@RequestMapping("/manage/inflow")
+public class ClientInflowTargetMetricController {
+
+    @Autowired
+    private ClientInflowTargetMetricService metricService;
+
+    @GetMapping("/client/metric")
+    public ResponseEntity<?> getAllClientMetrics() {
+        List<TargetMetricDTO> list = metricService.getAllClientMetrics();
+        return okList(list);
+    }
+
+    @GetMapping("/client/{clientId}/metric")
+    public ResponseEntity<?> getClientMetric(@PathVariable String clientId) {
+        TargetMetricDTO dto = metricService.getClientMetric(clientId);
+        return okSingle(dto, "클라이언트를 찾을 수 없습니다: " + clientId);
+    }
+
+    @PostMapping("/client/metric/reset")
+    public ResponseEntity<?> resetAllClientMetrics() {
+        metricService.resetAllClientMetrics();
+        return okReset("전체 클라이언트 메트릭 초기화 완료");
+    }
+
+    @PostMapping("/client/{clientId}/metric/reset")
+    public ResponseEntity<?> resetClientMetric(@PathVariable String clientId) {
+        boolean ok = metricService.resetClientMetric(clientId);
+        return okResetSingle(ok, clientId, "클라이언트");
+    }
+
+    private ResponseEntity<?> okList(List<TargetMetricDTO> list) {
+        Map<String, Object> result = new HashMap<>();
+        result.put("success", true);
+        result.put("data", list);
+        result.put("count", list.size());
+        return ResponseEntity.ok(result);
+    }
+
+    private ResponseEntity<?> okSingle(TargetMetricDTO dto, String notFoundMsg) {
+        if (dto == null) {
+            Map<String, Object> error = new HashMap<>();
+            error.put("success", false);
+            error.put("message", notFoundMsg);
+            return ResponseEntity.ok(error);
+        }
+        Map<String, Object> result = new HashMap<>();
+        result.put("success", true);
+        result.put("data", dto);
+        return ResponseEntity.ok(result);
+    }
+
+    private ResponseEntity<?> okReset(String message) {
+        Map<String, Object> result = new HashMap<>();
+        result.put("success", true);
+        result.put("message", message);
+        return ResponseEntity.ok(result);
+    }
+
+    private ResponseEntity<?> okResetSingle(boolean ok, String targetId, String targetLabel) {
+        Map<String, Object> result = new HashMap<>();
+        result.put("success", ok);
+        result.put("message", ok
+            ? "초기화 완료: " + targetId
+            : targetLabel + "를 찾을 수 없습니다: " + targetId);
+        return ResponseEntity.ok(result);
+    }
+}

src/main/java/com/eactive/eai/custom/inflow/ClientInflowTargetMetricService.java

@@ -0,0 +1,79 @@
+package com.eactive.eai.custom.inflow;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.springframework.stereotype.Service;
+
+import com.eactive.eai.common.inflow.AbstractInflowControlManager;
+import com.eactive.eai.common.inflow.InflowControlUtil;
+import com.eactive.eai.common.inflow.InflowTargetVO;
+import com.eactive.eai.common.inflow.dual.ClientDualInflowControlManager;
+import com.eactive.eai.common.inflow.dual.DualInflowControlManager;
+import com.eactive.eai.manage.inflow.TargetMetricDTO;
+
+@Service
+public class ClientInflowTargetMetricService {
+
+    public TargetMetricDTO getClientMetric(String clientId) {
+        ClientDualInflowControlManager manager = getClientDualManager();
+        if (manager == null) return null;
+        InflowTargetVO vo = manager.getClientInflowThreshold(clientId);
+        if (vo == null) return null;
+        return buildDTO(clientId, "CLIENT", vo, manager.getClientMetrics(clientId));
+    }
+
+    public List<TargetMetricDTO> getAllClientMetrics() {
+        ClientDualInflowControlManager manager = getClientDualManager();
+        if (manager == null) return new ArrayList<>();
+        List<TargetMetricDTO> result = new ArrayList<>();
+        for (String id : manager.getClientBucketMap().keySet()) {
+            TargetMetricDTO dto = getClientMetric(id);
+            if (dto != null) result.add(dto);
+        }
+        return result;
+    }
+
+    public boolean resetClientMetric(String clientId) {
+        ClientDualInflowControlManager manager = getClientDualManager();
+        if (manager == null) return false;
+        if (manager.getClientInflowThreshold(clientId) == null) return false;
+        manager.resetClientMetrics(clientId);
+        return true;
+    }
+
+    public void resetAllClientMetrics() {
+        ClientDualInflowControlManager manager = getClientDualManager();
+        if (manager != null) manager.resetAllClientMetrics();
+    }
+
+    protected ClientDualInflowControlManager getClientDualManager() {
+        AbstractInflowControlManager base = InflowControlUtil.getInflowControlManager();
+        return (base instanceof ClientDualInflowControlManager) ? (ClientDualInflowControlManager) base : null;
+    }
+
+    private TargetMetricDTO buildDTO(String targetId, String targetType,
+                                     InflowTargetVO vo,
+                                     DualInflowControlManager.TargetMetrics m) {
+        TargetMetricDTO dto = new TargetMetricDTO();
+        dto.setTargetId(targetId);
+        dto.setTargetType(targetType);
+        dto.setActivate(vo.isActivate());
+
+        if (m != null) {
+            long allowed = m.allowed.get();
+            long rejPs   = m.rejectedPerSecond.get();
+            long rejTh   = m.rejectedThreshold.get();
+            long total   = allowed + rejPs + rejTh;
+            dto.setAllowed(allowed);
+            dto.setRejectedPerSecond(rejPs);
+            dto.setRejectedThreshold(rejTh);
+            dto.setTotalRequests(total);
+            dto.setRejectRatio(total > 0
+                ? Math.round((double)(rejPs + rejTh) / total * 10000) / 100.0
+                : 0.0);
+            dto.setLastResetTime(m.lastResetTime);
+        }
+        return dto;
+    }
+}

src/main/java/com/eactive/eai/manage/inflow/InflowGroupBucketService.java

@@ -5,15 +5,16 @@ import java.util.List;
 
 import org.springframework.stereotype.Service;
 
+import com.eactive.eai.common.inflow.AbstractInflowControlManager;
 import com.eactive.eai.common.inflow.CustomGroupBucket;
-import com.eactive.eai.common.inflow.InflowControlManager;
+import com.eactive.eai.common.inflow.InflowControlUtil;
 import com.eactive.eai.common.inflow.InflowGroupVO;
 
 @Service
 public class InflowGroupBucketService {
 
     public GroupBucketStatusDTO getGroupBucketStatus(String groupId) {
-        InflowControlManager manager = InflowControlManager.getInstance();
+        AbstractInflowControlManager manager = InflowControlUtil.getInflowControlManager();
 
         InflowGroupVO groupVo = manager.getGroupInflowThreshold(groupId);
         if (groupVo == null) {
@@ -71,11 +72,11 @@ public class InflowGroupBucketService {
     }
 
     public CustomGroupBucket getCustomGroupBucket(String groupId) {
-        return InflowControlManager.getInstance().getGroupBucket(groupId);
+        return InflowControlUtil.getInflowControlManager().getGroupBucket(groupId);
     }
 
     public List<GroupBucketStatusDTO> getAllGroupBucketStatus() {
-        InflowControlManager manager = InflowControlManager.getInstance();
+        AbstractInflowControlManager manager = InflowControlUtil.getInflowControlManager();
         String[] groupIds = manager.getGroupAllKeys();
 
         List<GroupBucketStatusDTO> result = new ArrayList<>();

src/main/java/com/eactive/eai/manage/inflow/InflowTargetBucketController.java

@@ -0,0 +1,88 @@
+package com.eactive.eai.manage.inflow;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * 어댑터/인터페이스/클라이언트 버킷 상태 모니터링 API.
+ *
+ * DualInflowControlManager 가 활성화된 환경에서만 정상 응답한다.
+ * 비활성화 환경에서는 success=false 또는 빈 목록을 반환한다.
+ *
+ * GET /manage/inflow/adapter/bucket-status             → 전체 어댑터 버킷 상태
+ * GET /manage/inflow/adapter/{adapterId}/bucket-status → 특정 어댑터 버킷 상태
+ * GET /manage/inflow/interface/bucket-status           → 전체 인터페이스 버킷 상태
+ * GET /manage/inflow/interface/{interfaceId}/bucket-status → 특정 인터페이스 버킷 상태
+ */
+@RestController
+@RequestMapping("/manage/inflow")
+public class InflowTargetBucketController {
+
+    @Autowired
+    private InflowTargetBucketService bucketService;
+
+    // =========================================================================
+    // 어댑터
+    // =========================================================================
+
+    @GetMapping("/adapter/bucket-status")
+    public ResponseEntity<?> getAllAdapterBucketStatus() {
+        List<TargetBucketStatusDTO> list = bucketService.getAllAdapterBucketStatus();
+        return ok(list);
+    }
+
+    @GetMapping("/adapter/{adapterId}/bucket-status")
+    public ResponseEntity<?> getAdapterBucketStatus(@PathVariable String adapterId) {
+        TargetBucketStatusDTO dto = bucketService.getAdapterBucketStatus(adapterId);
+        return single(dto, "어댑터를 찾을 수 없습니다: " + adapterId);
+    }
+
+    // =========================================================================
+    // 인터페이스
+    // =========================================================================
+
+    @GetMapping("/interface/bucket-status")
+    public ResponseEntity<?> getAllInterfaceBucketStatus() {
+        List<TargetBucketStatusDTO> list = bucketService.getAllInterfaceBucketStatus();
+        return ok(list);
+    }
+
+    @GetMapping("/interface/{interfaceId}/bucket-status")
+    public ResponseEntity<?> getInterfaceBucketStatus(@PathVariable String interfaceId) {
+        TargetBucketStatusDTO dto = bucketService.getInterfaceBucketStatus(interfaceId);
+        return single(dto, "인터페이스를 찾을 수 없습니다: " + interfaceId);
+    }
+
+    // =========================================================================
+    // Helpers
+    // =========================================================================
+
+    private ResponseEntity<?> ok(List<TargetBucketStatusDTO> list) {
+        Map<String, Object> result = new HashMap<>();
+        result.put("success", true);
+        result.put("data", list);
+        result.put("count", list.size());
+        return ResponseEntity.ok(result);
+    }
+
+    private ResponseEntity<?> single(TargetBucketStatusDTO dto, String notFoundMsg) {
+        if (dto == null) {
+            Map<String, Object> error = new HashMap<>();
+            error.put("success", false);
+            error.put("message", notFoundMsg);
+            return ResponseEntity.ok(error);
+        }
+        Map<String, Object> result = new HashMap<>();
+        result.put("success", true);
+        result.put("data", dto);
+        return ResponseEntity.ok(result);
+    }
+}

src/main/java/com/eactive/eai/manage/inflow/InflowTargetBucketService.java

@@ -0,0 +1,104 @@
+package com.eactive.eai.manage.inflow;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import org.springframework.stereotype.Service;
+
+import com.eactive.eai.common.inflow.AbstractInflowControlManager;
+import com.eactive.eai.common.inflow.InflowControlUtil;
+import com.eactive.eai.common.inflow.InflowTargetVO;
+import com.eactive.eai.common.inflow.dual.DualCustomBucket;
+import com.eactive.eai.common.inflow.dual.DualInflowControlManager;
+
+/**
+ * 어댑터/인터페이스/클라이언트 버킷 상태 조회 서비스.
+ *
+ * DualInflowControlManager 가 활성화된 경우에만 동작한다.
+ * InflowControlManager 가 기본 구현체인 경우 빈 목록 또는 null 을 반환한다.
+ */
+@Service
+public class InflowTargetBucketService {
+
+    // -------------------------------------------------------------------------
+    // 어댑터
+    // -------------------------------------------------------------------------
+
+    public TargetBucketStatusDTO getAdapterBucketStatus(String adapterId) {
+        DualInflowControlManager manager = getDualManager();
+        if (manager == null) return null;
+        DualCustomBucket bucket = manager.getAdapterBucket(adapterId);
+        if (bucket == null) return null;
+        return toDto(adapterId, "ADAPTER", bucket);
+    }
+
+    public List<TargetBucketStatusDTO> getAllAdapterBucketStatus() {
+        DualInflowControlManager manager = getDualManager();
+        if (manager == null) return new ArrayList<>();
+        return toDtoList("ADAPTER", manager.getAdapterBucketMap());
+    }
+
+    // -------------------------------------------------------------------------
+    // 인터페이스
+    // -------------------------------------------------------------------------
+
+    public TargetBucketStatusDTO getInterfaceBucketStatus(String interfaceId) {
+        DualInflowControlManager manager = getDualManager();
+        if (manager == null) return null;
+        DualCustomBucket bucket = manager.getInterfaceBucket(interfaceId);
+        if (bucket == null) return null;
+        return toDto(interfaceId, "INTERFACE", bucket);
+    }
+
+    public List<TargetBucketStatusDTO> getAllInterfaceBucketStatus() {
+        DualInflowControlManager manager = getDualManager();
+        if (manager == null) return new ArrayList<>();
+        return toDtoList("INTERFACE", manager.getInterfaceBucketMap());
+    }
+
+    // -------------------------------------------------------------------------
+    // Private helpers
+    // -------------------------------------------------------------------------
+
+    protected DualInflowControlManager getDualManager() {
+        AbstractInflowControlManager base = InflowControlUtil.getInflowControlManager();
+        return (base instanceof DualInflowControlManager) ? (DualInflowControlManager) base : null;
+    }
+
+    private TargetBucketStatusDTO toDto(String targetId, String targetType, DualCustomBucket bucket) {
+        InflowTargetVO vo = bucket.getInflowTargetVo();
+        List<GroupBucketStatusDTO.BucketInfo> buckets = new ArrayList<>();
+
+        if (vo.getThresholdPerSecond() > 0) {
+            long capacity  = vo.getThresholdPerSecond();
+            long available = bucket.getPerSecondAvailableTokens();
+            if (available < 0) available = capacity;
+            buckets.add(new GroupBucketStatusDTO.BucketInfo(
+                    "perSecond", capacity, Math.min(available, capacity), "SEC"));
+        }
+
+        if (vo.getThreshold() > 0) {
+            long capacity  = vo.getThreshold();
+            long available = bucket.getThresholdAvailableTokens();
+            if (available < 0) available = capacity;
+            buckets.add(new GroupBucketStatusDTO.BucketInfo(
+                    "threshold", capacity, Math.min(available, capacity), vo.getThresholdTimeUnit()));
+        }
+
+        TargetBucketStatusDTO dto = new TargetBucketStatusDTO();
+        dto.setTargetId(targetId);
+        dto.setTargetType(targetType);
+        dto.setActivate(vo.isActivate());
+        dto.setBuckets(buckets);
+        return dto;
+    }
+
+    private List<TargetBucketStatusDTO> toDtoList(String targetType, Map<String, DualCustomBucket> bucketMap) {
+        List<TargetBucketStatusDTO> result = new ArrayList<>();
+        for (Map.Entry<String, DualCustomBucket> entry : bucketMap.entrySet()) {
+            result.add(toDto(entry.getKey(), targetType, entry.getValue()));
+        }
+        return result;
+    }
+}

src/main/java/com/eactive/eai/manage/inflow/InflowTargetMetricController.java

@@ -0,0 +1,133 @@
+package com.eactive.eai.manage.inflow;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * 어댑터/인터페이스 유량제어 메트릭 API.
+ *
+ * DualInflowControlManager 가 활성화된 환경에서만 정상 응답한다.
+ *
+ * GET  /manage/inflow/adapter/metric                      → 전체 어댑터 메트릭
+ * GET  /manage/inflow/adapter/{adapterId}/metric          → 특정 어댑터 메트릭
+ * POST /manage/inflow/adapter/metric/reset                → 전체 어댑터 메트릭 초기화
+ * POST /manage/inflow/adapter/{adapterId}/metric/reset    → 특정 어댑터 메트릭 초기화
+ *
+ * GET  /manage/inflow/interface/metric                    → 전체 인터페이스 메트릭
+ * GET  /manage/inflow/interface/{interfaceId}/metric      → 특정 인터페이스 메트릭
+ * POST /manage/inflow/interface/metric/reset              → 전체 인터페이스 메트릭 초기화
+ * POST /manage/inflow/interface/{interfaceId}/metric/reset → 특정 인터페이스 메트릭 초기화
+ */
+@RestController
+@RequestMapping("/manage/inflow")
+public class InflowTargetMetricController {
+
+    @Autowired
+    private InflowTargetMetricService metricService;
+
+    // =========================================================================
+    // 어댑터
+    // =========================================================================
+
+    @GetMapping("/adapter/metric")
+    public ResponseEntity<?> getAllAdapterMetrics() {
+        List<TargetMetricDTO> list = metricService.getAllAdapterMetrics();
+        return okList(list);
+    }
+
+    @GetMapping("/adapter/{adapterId}/metric")
+    public ResponseEntity<?> getAdapterMetric(@PathVariable String adapterId) {
+        TargetMetricDTO dto = metricService.getAdapterMetric(adapterId);
+        return okSingle(dto, "어댑터를 찾을 수 없습니다: " + adapterId);
+    }
+
+    @PostMapping("/adapter/metric/reset")
+    public ResponseEntity<?> resetAllAdapterMetrics() {
+        metricService.resetAllAdapterMetrics();
+        return okReset("전체 어댑터 메트릭 초기화 완료");
+    }
+
+    @PostMapping("/adapter/{adapterId}/metric/reset")
+    public ResponseEntity<?> resetAdapterMetric(@PathVariable String adapterId) {
+        boolean ok = metricService.resetAdapterMetric(adapterId);
+        return okResetSingle(ok, adapterId, "어댑터");
+    }
+
+    // =========================================================================
+    // 인터페이스
+    // =========================================================================
+
+    @GetMapping("/interface/metric")
+    public ResponseEntity<?> getAllInterfaceMetrics() {
+        List<TargetMetricDTO> list = metricService.getAllInterfaceMetrics();
+        return okList(list);
+    }
+
+    @GetMapping("/interface/{interfaceId}/metric")
+    public ResponseEntity<?> getInterfaceMetric(@PathVariable String interfaceId) {
+        TargetMetricDTO dto = metricService.getInterfaceMetric(interfaceId);
+        return okSingle(dto, "인터페이스를 찾을 수 없습니다: " + interfaceId);
+    }
+
+    @PostMapping("/interface/metric/reset")
+    public ResponseEntity<?> resetAllInterfaceMetrics() {
+        metricService.resetAllInterfaceMetrics();
+        return okReset("전체 인터페이스 메트릭 초기화 완료");
+    }
+
+    @PostMapping("/interface/{interfaceId}/metric/reset")
+    public ResponseEntity<?> resetInterfaceMetric(@PathVariable String interfaceId) {
+        boolean ok = metricService.resetInterfaceMetric(interfaceId);
+        return okResetSingle(ok, interfaceId, "인터페이스");
+    }
+
+    // =========================================================================
+    // Helpers
+    // =========================================================================
+
+    private ResponseEntity<?> okList(List<TargetMetricDTO> list) {
+        Map<String, Object> result = new HashMap<>();
+        result.put("success", true);
+        result.put("data", list);
+        result.put("count", list.size());
+        return ResponseEntity.ok(result);
+    }
+
+    private ResponseEntity<?> okSingle(TargetMetricDTO dto, String notFoundMsg) {
+        if (dto == null) {
+            Map<String, Object> error = new HashMap<>();
+            error.put("success", false);
+            error.put("message", notFoundMsg);
+            return ResponseEntity.ok(error);
+        }
+        Map<String, Object> result = new HashMap<>();
+        result.put("success", true);
+        result.put("data", dto);
+        return ResponseEntity.ok(result);
+    }
+
+    private ResponseEntity<?> okReset(String message) {
+        Map<String, Object> result = new HashMap<>();
+        result.put("success", true);
+        result.put("message", message);
+        return ResponseEntity.ok(result);
+    }
+
+    private ResponseEntity<?> okResetSingle(boolean ok, String targetId, String targetLabel) {
+        Map<String, Object> result = new HashMap<>();
+        result.put("success", ok);
+        result.put("message", ok
+            ? "초기화 완료: " + targetId
+            : targetLabel + "를 찾을 수 없습니다: " + targetId);
+        return ResponseEntity.ok(result);
+    }
+}

src/main/java/com/eactive/eai/manage/inflow/InflowTargetMetricService.java

@@ -0,0 +1,121 @@
+package com.eactive.eai.manage.inflow;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.springframework.stereotype.Service;
+
+import com.eactive.eai.common.inflow.AbstractInflowControlManager;
+import com.eactive.eai.common.inflow.InflowControlUtil;
+import com.eactive.eai.common.inflow.InflowTargetVO;
+import com.eactive.eai.common.inflow.dual.DualInflowControlManager;
+
+@Service
+public class InflowTargetMetricService {
+
+    // -------------------------------------------------------------------------
+    // 어댑터
+    // -------------------------------------------------------------------------
+
+    public TargetMetricDTO getAdapterMetric(String adapterId) {
+        DualInflowControlManager manager = getDualManager();
+        if (manager == null) return null;
+        InflowTargetVO vo = manager.getAdapterInflowThreashold(adapterId);
+        if (vo == null) return null;
+        return buildDTO(adapterId, "ADAPTER", vo, manager.getAdapterMetrics(adapterId));
+    }
+
+    public List<TargetMetricDTO> getAllAdapterMetrics() {
+        DualInflowControlManager manager = getDualManager();
+        if (manager == null) return new ArrayList<>();
+        List<TargetMetricDTO> result = new ArrayList<>();
+        for (String id : manager.getAdapterAllKeys()) {
+            TargetMetricDTO dto = getAdapterMetric(id);
+            if (dto != null) result.add(dto);
+        }
+        return result;
+    }
+
+    public boolean resetAdapterMetric(String adapterId) {
+        DualInflowControlManager manager = getDualManager();
+        if (manager == null) return false;
+        if (manager.getAdapterInflowThreashold(adapterId) == null) return false;
+        manager.resetAdapterMetrics(adapterId);
+        return true;
+    }
+
+    public void resetAllAdapterMetrics() {
+        DualInflowControlManager manager = getDualManager();
+        if (manager != null) manager.resetAllAdapterMetrics();
+    }
+
+    // -------------------------------------------------------------------------
+    // 인터페이스
+    // -------------------------------------------------------------------------
+
+    public TargetMetricDTO getInterfaceMetric(String interfaceId) {
+        DualInflowControlManager manager = getDualManager();
+        if (manager == null) return null;
+        InflowTargetVO vo = manager.getInterfaceInflowThreashold(interfaceId);
+        if (vo == null) return null;
+        return buildDTO(interfaceId, "INTERFACE", vo, manager.getInterfaceMetrics(interfaceId));
+    }
+
+    public List<TargetMetricDTO> getAllInterfaceMetrics() {
+        DualInflowControlManager manager = getDualManager();
+        if (manager == null) return new ArrayList<>();
+        List<TargetMetricDTO> result = new ArrayList<>();
+        for (String id : manager.getInterfaceAllKeys()) {
+            TargetMetricDTO dto = getInterfaceMetric(id);
+            if (dto != null) result.add(dto);
+        }
+        return result;
+    }
+
+    public boolean resetInterfaceMetric(String interfaceId) {
+        DualInflowControlManager manager = getDualManager();
+        if (manager == null) return false;
+        if (manager.getInterfaceInflowThreashold(interfaceId) == null) return false;
+        manager.resetInterfaceMetrics(interfaceId);
+        return true;
+    }
+
+    public void resetAllInterfaceMetrics() {
+        DualInflowControlManager manager = getDualManager();
+        if (manager != null) manager.resetAllInterfaceMetrics();
+    }
+
+    // -------------------------------------------------------------------------
+    // Private helpers
+    // -------------------------------------------------------------------------
+
+    protected DualInflowControlManager getDualManager() {
+        AbstractInflowControlManager base = InflowControlUtil.getInflowControlManager();
+        return (base instanceof DualInflowControlManager) ? (DualInflowControlManager) base : null;
+    }
+
+    private TargetMetricDTO buildDTO(String targetId, String targetType,
+                                     InflowTargetVO vo,
+                                     DualInflowControlManager.TargetMetrics m) {
+        TargetMetricDTO dto = new TargetMetricDTO();
+        dto.setTargetId(targetId);
+        dto.setTargetType(targetType);
+        dto.setActivate(vo.isActivate());
+
+        if (m != null) {
+            long allowed = m.allowed.get();
+            long rejPs   = m.rejectedPerSecond.get();
+            long rejTh   = m.rejectedThreshold.get();
+            long total   = allowed + rejPs + rejTh;
+            dto.setAllowed(allowed);
+            dto.setRejectedPerSecond(rejPs);
+            dto.setRejectedThreshold(rejTh);
+            dto.setTotalRequests(total);
+            dto.setRejectRatio(total > 0
+                ? Math.round((double)(rejPs + rejTh) / total * 10000) / 100.0
+                : 0.0);
+            dto.setLastResetTime(m.lastResetTime);
+        }
+        return dto;
+    }
+}

src/main/java/com/eactive/eai/manage/inflow/TargetBucketStatusDTO.java

@@ -0,0 +1,27 @@
+package com.eactive.eai.manage.inflow;
+
+import java.util.List;
+
+/**
+ * 어댑터/인터페이스/클라이언트 버킷 상태 DTO.
+ * {@link GroupBucketStatusDTO}와 동일한 BucketInfo 구조를 공유한다.
+ */
+public class TargetBucketStatusDTO {
+
+    private String targetId;    // 어댑터명 | 인터페이스ID | 클라이언트ID
+    private String targetType;  // "ADAPTER" | "INTERFACE" | "CLIENT"
+    private boolean activate;
+    private List<GroupBucketStatusDTO.BucketInfo> buckets;
+
+    public String getTargetId() { return targetId; }
+    public void setTargetId(String targetId) { this.targetId = targetId; }
+
+    public String getTargetType() { return targetType; }
+    public void setTargetType(String targetType) { this.targetType = targetType; }
+
+    public boolean isActivate() { return activate; }
+    public void setActivate(boolean activate) { this.activate = activate; }
+
+    public List<GroupBucketStatusDTO.BucketInfo> getBuckets() { return buckets; }
+    public void setBuckets(List<GroupBucketStatusDTO.BucketInfo> buckets) { this.buckets = buckets; }
+}

src/main/java/com/eactive/eai/manage/inflow/TargetMetricDTO.java

@@ -0,0 +1,44 @@
+package com.eactive.eai.manage.inflow;
+
+/**
+ * 어댑터/인터페이스/클라이언트 메트릭 DTO.
+ */
+public class TargetMetricDTO {
+
+    private String  targetId;
+    private String  targetType;   // "ADAPTER" | "INTERFACE" | "CLIENT"
+    private boolean activate;
+    private long    allowed;
+    private long    rejectedPerSecond;
+    private long    rejectedThreshold;
+    private long    totalRequests;
+    private double  rejectRatio;
+    private long    lastResetTime;
+
+    public String getTargetId()                       { return targetId; }
+    public void   setTargetId(String targetId)        { this.targetId = targetId; }
+
+    public String getTargetType()                     { return targetType; }
+    public void   setTargetType(String targetType)    { this.targetType = targetType; }
+
+    public boolean isActivate()                       { return activate; }
+    public void    setActivate(boolean activate)      { this.activate = activate; }
+
+    public long getAllowed()                           { return allowed; }
+    public void setAllowed(long allowed)              { this.allowed = allowed; }
+
+    public long getRejectedPerSecond()                          { return rejectedPerSecond; }
+    public void setRejectedPerSecond(long rejectedPerSecond)    { this.rejectedPerSecond = rejectedPerSecond; }
+
+    public long getRejectedThreshold()                          { return rejectedThreshold; }
+    public void setRejectedThreshold(long rejectedThreshold)    { this.rejectedThreshold = rejectedThreshold; }
+
+    public long getTotalRequests()                    { return totalRequests; }
+    public void setTotalRequests(long totalRequests)  { this.totalRequests = totalRequests; }
+
+    public double getRejectRatio()                    { return rejectRatio; }
+    public void   setRejectRatio(double rejectRatio)  { this.rejectRatio = rejectRatio; }
+
+    public long getLastResetTime()                    { return lastResetTime; }
+    public void setLastResetTime(long lastResetTime)  { this.lastResetTime = lastResetTime; }
+}

src/main/resources/standard-message-config.properties

@@ -8,7 +8,7 @@ mapper.definition=standard-message-mapping-config-djb.properties
 # StandardMessage Coordinator implementation
 message.coordinator.class=com.eactive.eai.custom.message.StandardMessageCoordinatorDJB
 # RequestProcessor implementation
-requestProcessor.class=com.eactive.eai.inbound.processor.DualRequestProcessor
+requestProcessor.class=com.eactive.eai.custom.inbound.processor.DJBRequestProcessor
 # reader : parsing input data to StandardMessage
 reader.JSON=com.eactive.eai.message.parser.JsonReader
 reader.JSN=com.eactive.eai.message.parser.JsonReader

src/test/java/com/eactive/eai/custom/adapter/http/dynamic/filter/DJBErpCryptoFilterTest.java

@@ -0,0 +1,317 @@
+package com.eactive.eai.custom.adapter.http.dynamic.filter;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Base64;
+import java.util.Map;
+import java.util.Properties;
+
+import org.mockito.ArgumentCaptor;
+
+import javax.servlet.http.HttpServletRequest;
+
+import org.json.simple.JSONObject;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.context.support.GenericApplicationContext;
+
+import com.eactive.eai.common.security.CryptoModuleService;
+import com.eactive.eai.common.util.ApplicationContextProvider;
+
+@TestMethodOrder(MethodOrderer.DisplayName.class)
+class DJBErpCryptoFilterTest {
+
+    private static final String MODULE_NAME = "TEST_MODULE";
+    // 복호화 후 평문 (JSON 문자열)
+    private static final String PLAIN_TEXT  = "{\"userId\":\"U001\",\"name\":\"test\"}";
+    private static final byte[] PLAIN_BYTES = PLAIN_TEXT.getBytes(StandardCharsets.UTF_8);
+    // 더미 암호문 bytes + Base64 표현
+    private static final byte[] CIPHER_BYTES = new byte[]{0x10, 0x20, 0x30, 0x40};
+    private static final String ENC_BASE64   = Base64.getEncoder().encodeToString(CIPHER_BYTES);
+
+    // 기본 httpHeaderGroup 헤더 JSON (groupSeq|empNo 형태)
+    private static final String HEADER_JSON_WITH_PIPE   = "{\"x-emp-nm\":\"G001|E001\"}";
+    private static final String HEADER_JSON_WITHOUT_PIPE = "{\"x-emp-nm\":\"G001\"}";
+
+    private static GenericApplicationContext ctx;
+    private static CryptoModuleService       mockCryptoService;
+
+    private DJBErpCryptoFilter filter;
+    private HttpServletRequest mockRequest;
+    private Properties         prop;
+
+    // =========================================================================
+    // 클래스 초기화 — Spring ApplicationContext + Mock CryptoModuleService
+    // =========================================================================
+
+    @BeforeAll
+    static void setUpClass() throws Exception {
+        mockCryptoService = mock(CryptoModuleService.class);
+
+        ctx = new GenericApplicationContext();
+        ctx.getBeanFactory().registerSingleton("cryptoModuleService", mockCryptoService);
+        ctx.registerBeanDefinition("applicationContextProvider",
+                BeanDefinitionBuilder.genericBeanDefinition(ApplicationContextProvider.class)
+                        .getBeanDefinition());
+        ctx.refresh();
+
+        when(mockCryptoService.decrypt(anyString(), anyMap(), any(byte[].class)))
+                .thenReturn(PLAIN_BYTES);
+        when(mockCryptoService.encrypt(anyString(), anyMap(), any(byte[].class)))
+                .thenReturn(CIPHER_BYTES);
+    }
+
+    @AfterAll
+    static void tearDownClass() {
+        if (ctx != null) ctx.close();
+    }
+
+    @BeforeEach
+    void setUp() {
+        clearInvocations(mockCryptoService); // 이전 테스트의 호출 이력 초기화 (stubbing은 유지)
+        filter      = new DJBErpCryptoFilter();
+        mockRequest = mock(HttpServletRequest.class);
+        prop        = new Properties();
+        prop.setProperty(DJBErpCryptoFilter.PROP_MODULE_NAME, MODULE_NAME);
+    }
+
+    // =========================================================================
+    // 1. buildRuntimeContext
+    // =========================================================================
+
+    @Test
+    @DisplayName("1-1. x-emp-nm이 'groupSeq|empNo' 형태이면 '|' 앞부분만 groupSeq로 추출")
+    void buildRuntimeContext_pipeFormat_extractsGroupSeqOnly() {
+        when(mockRequest.getHeader("httpHeaderGroup")).thenReturn(HEADER_JSON_WITH_PIPE);
+
+        Map<String, String> runtimeCtx = filter.buildRuntimeContext(prop, mockRequest);
+
+        assertEquals("G001", runtimeCtx.get("groupSeq"));
+        assertEquals(1, runtimeCtx.size());
+    }
+
+    @Test
+    @DisplayName("1-2. x-emp-nm에 '|'가 없으면 전체 값을 groupSeq로 사용")
+    void buildRuntimeContext_noPipe_usesFullValue() {
+        when(mockRequest.getHeader("httpHeaderGroup")).thenReturn(HEADER_JSON_WITHOUT_PIPE);
+
+        Map<String, String> runtimeCtx = filter.buildRuntimeContext(prop, mockRequest);
+
+        assertEquals("G001", runtimeCtx.get("groupSeq"));
+    }
+
+    @Test
+    @DisplayName("1-3. httpHeaderGroup 헤더가 없으면 빈 Map 반환")
+    void buildRuntimeContext_headerMissing_returnsEmptyMap() {
+        when(mockRequest.getHeader("httpHeaderGroup")).thenReturn(null);
+
+        Map<String, String> runtimeCtx = filter.buildRuntimeContext(prop, mockRequest);
+
+        assertTrue(runtimeCtx.isEmpty());
+    }
+
+    @Test
+    @DisplayName("1-4. 헤더 JSON에 x-emp-nm 필드가 없으면 빈 Map 반환")
+    void buildRuntimeContext_fieldMissingInJson_returnsEmptyMap() {
+        when(mockRequest.getHeader("httpHeaderGroup")).thenReturn("{\"other-field\":\"value\"}");
+
+        Map<String, String> runtimeCtx = filter.buildRuntimeContext(prop, mockRequest);
+
+        assertTrue(runtimeCtx.isEmpty());
+    }
+
+    @Test
+    @DisplayName("1-5. 프로퍼티로 헤더명/필드명/컨텍스트키를 커스터마이징할 수 있다")
+    void buildRuntimeContext_customProps_overrideDefaults() {
+        prop.setProperty(DJBErpCryptoFilter.PROP_CONTEXT_HEADER,       "X-Custom-Header");
+        prop.setProperty(DJBErpCryptoFilter.PROP_CONTEXT_HEADER_FIELD, "emp-id");
+        prop.setProperty(DJBErpCryptoFilter.PROP_CONTEXT_KEY,          "empGroup");
+
+        when(mockRequest.getHeader("X-Custom-Header")).thenReturn("{\"emp-id\":\"GRP99|EMP99\"}");
+
+        Map<String, String> runtimeCtx = filter.buildRuntimeContext(prop, mockRequest);
+
+        assertEquals("GRP99", runtimeCtx.get("empGroup"));
+    }
+
+    // =========================================================================
+    // 2. doPreFilter — 복호화
+    // =========================================================================
+
+    @Test
+    @DisplayName("2-1. crypto.dec.enabled=N 이면 message를 그대로 반환하고 복호화하지 않는다")
+    void doPreFilter_decDisabled_returnsOriginalWithoutDecrypt() throws Exception {
+        prop.setProperty("crypto.dec.enabled", "N");
+        String original = "{\"encryptedData\":\"" + ENC_BASE64 + "\"}";
+
+        Object result = filter.doPreFilter(null, null, original, prop, mockRequest, null);
+
+        assertSame(original, result);
+        verifyNoInteractions(mockCryptoService);
+    }
+
+    @Test
+    @DisplayName("2-2. FIELD scope: /encryptedData 복호화 후 dec.to.path=/ 이면 body 전체를 평문으로 교체")
+    void doPreFilter_fieldScope_toRoot_replacesEntireBody() throws Exception {
+        setFieldDecryptProps("/encryptedData", "/");
+        when(mockRequest.getHeader("httpHeaderGroup")).thenReturn(HEADER_JSON_WITH_PIPE);
+
+        String body = "{\"encryptedData\":\"" + ENC_BASE64 + "\"}";
+        Object result = filter.doPreFilter(null, null, body, prop, mockRequest, null);
+
+        assertEquals(PLAIN_TEXT, result);
+    }
+
+    @Test
+    @DisplayName("2-3. FIELD scope: dec.to.path가 특정 경로이면 해당 필드에 복호화 결과를 설정")
+    void doPreFilter_fieldScope_toSpecificPath_setsFieldInBody() throws Exception {
+        setFieldDecryptProps("/encryptedData", "/plainData");
+        when(mockRequest.getHeader("httpHeaderGroup")).thenReturn(HEADER_JSON_WITH_PIPE);
+
+        String body   = "{\"encryptedData\":\"" + ENC_BASE64 + "\"}";
+        String result = (String) filter.doPreFilter(null, null, body, prop, mockRequest, null);
+
+        assertTrue(result.contains("\"encryptedData\""), "원본 필드가 유지되어야 한다");
+        assertTrue(result.contains("\"plainData\""),     "복호화 결과 필드가 추가되어야 한다");
+    }
+
+    @Test
+    @DisplayName("2-4. FIELD scope: 복호화 대상 필드가 JSON에 없으면 원본 body를 그대로 반환")
+    void doPreFilter_fieldScope_missingEncryptedField_returnsOriginalBody() throws Exception {
+        setFieldDecryptProps("/encryptedData", "/");
+        when(mockRequest.getHeader("httpHeaderGroup")).thenReturn(HEADER_JSON_WITH_PIPE);
+
+        String body = "{\"otherField\":\"value\"}";
+        Object result = filter.doPreFilter(null, null, body, prop, mockRequest, null);
+
+        assertEquals(body, result);
+    }
+
+    @Test
+    @DisplayName("2-5. BODY scope: message가 Base64 String이면 전체 복호화")
+    void doPreFilter_bodyScope_stringMessage_decryptsWholeBody() throws Exception {
+        prop.setProperty("crypto.scope", "BODY");
+
+        Object result = filter.doPreFilter(null, null, ENC_BASE64, prop, mockRequest, null);
+
+        assertEquals(PLAIN_TEXT, result);
+    }
+
+    @Test
+    @DisplayName("2-6. message가 byte[]이면 UTF-8 변환 후 FIELD 복호화 처리")
+    void doPreFilter_fieldScope_byteArrayMessage_convertsAndDecrypts() throws Exception {
+        setFieldDecryptProps("/encryptedData", "/");
+        when(mockRequest.getHeader("httpHeaderGroup")).thenReturn(HEADER_JSON_WITH_PIPE);
+
+        byte[] bodyBytes = ("{\"encryptedData\":\"" + ENC_BASE64 + "\"}").getBytes(StandardCharsets.UTF_8);
+
+        Object result = filter.doPreFilter(null, null, bodyBytes, prop, mockRequest, null);
+
+        assertEquals(PLAIN_TEXT, result);
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    @DisplayName("2-7. message가 JSONObject이면 toString() 변환 후 FIELD 복호화 처리")
+    void doPreFilter_fieldScope_jsonObjectMessage_convertsAndDecrypts() throws Exception {
+        setFieldDecryptProps("/encryptedData", "/");
+        when(mockRequest.getHeader("httpHeaderGroup")).thenReturn(HEADER_JSON_WITH_PIPE);
+
+        JSONObject jsonMsg = new JSONObject();
+        jsonMsg.put("encryptedData", ENC_BASE64);
+
+        Object result = filter.doPreFilter(null, null, jsonMsg, prop, mockRequest, null);
+
+        assertEquals(PLAIN_TEXT, result);
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    @DisplayName("2-8. FIELD scope: runtimeContext에 groupSeq가 올바르게 전달된다")
+    void doPreFilter_fieldScope_runtimeContextPassedToDecrypt() throws Exception {
+        setFieldDecryptProps("/encryptedData", "/");
+        when(mockRequest.getHeader("httpHeaderGroup")).thenReturn(HEADER_JSON_WITH_PIPE);
+
+        String body = "{\"encryptedData\":\"" + ENC_BASE64 + "\"}";
+        filter.doPreFilter(null, null, body, prop, mockRequest, null);
+
+        ArgumentCaptor<Map> ctxCaptor = ArgumentCaptor.forClass(Map.class);
+        verify(mockCryptoService).decrypt(eq(MODULE_NAME), ctxCaptor.capture(), any(byte[].class));
+        assertEquals("G001", ctxCaptor.getValue().get("groupSeq"));
+    }
+
+    // =========================================================================
+    // 3. doPostFilter — 암호화
+    // =========================================================================
+
+    @Test
+    @DisplayName("3-1. crypto.enc.enabled 기본값(N) — resultMessage를 그대로 반환하고 암호화하지 않는다")
+    void doPostFilter_encDisabledByDefault_returnsOriginalWithoutEncrypt() throws Exception {
+        String original = "{\"result\":\"ok\"}";
+
+        Object result = filter.doPostFilter(null, null, original, prop, mockRequest, null);
+
+        assertSame(original, result);
+        verifyNoInteractions(mockCryptoService);
+    }
+
+    @Test
+    @DisplayName("3-2. BODY scope, enc.enabled=Y — body 전체를 암호화하여 Base64 반환")
+    void doPostFilter_bodyScope_encEnabled_returnsBase64() throws Exception {
+        prop.setProperty("crypto.scope",       "BODY");
+        prop.setProperty("crypto.enc.enabled", "Y");
+
+        Object result = filter.doPostFilter(null, null, PLAIN_TEXT, prop, mockRequest, null);
+
+        assertEquals(ENC_BASE64, result);
+    }
+
+    @Test
+    @DisplayName("3-3. FIELD scope, enc.from.path=/ — body 전체 암호화 후 enc.to.path 필드로 래핑")
+    void doPostFilter_fieldScope_fromRoot_wrapsEncryptedInJson() throws Exception {
+        prop.setProperty("crypto.scope",         "FIELD");
+        prop.setProperty("crypto.enc.enabled",   "Y");
+        prop.setProperty("crypto.enc.from.path", "/");
+        prop.setProperty("crypto.enc.to.path",   "/encryptedData");
+
+        Object result = filter.doPostFilter(null, null, PLAIN_TEXT, prop, mockRequest, null);
+
+        assertEquals("{\"encryptedData\":\"" + ENC_BASE64 + "\"}", result);
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    @DisplayName("3-4. FIELD scope: runtimeContext에 groupSeq가 올바르게 전달된다")
+    void doPostFilter_fieldScope_runtimeContextPassedToEncrypt() throws Exception {
+        prop.setProperty("crypto.scope",         "FIELD");
+        prop.setProperty("crypto.enc.enabled",   "Y");
+        prop.setProperty("crypto.enc.from.path", "/");
+        prop.setProperty("crypto.enc.to.path",   "/encryptedData");
+        when(mockRequest.getHeader("httpHeaderGroup")).thenReturn(HEADER_JSON_WITH_PIPE);
+
+        filter.doPostFilter(null, null, PLAIN_TEXT, prop, mockRequest, null);
+
+        ArgumentCaptor<Map> ctxCaptor = ArgumentCaptor.forClass(Map.class);
+        verify(mockCryptoService).encrypt(eq(MODULE_NAME), ctxCaptor.capture(), any(byte[].class));
+        assertEquals("G001", ctxCaptor.getValue().get("groupSeq"));
+    }
+
+    // =========================================================================
+    // 헬퍼
+    // =========================================================================
+
+    private void setFieldDecryptProps(String fromPath, String toPath) {
+        prop.setProperty("crypto.scope",          "FIELD");
+        prop.setProperty("crypto.dec.from.path",  fromPath);
+        prop.setProperty("crypto.dec.to.path",    toPath);
+    }
+}

src/test/java/com/eactive/eai/custom/inbound/processor/DJBRequestProcessorTest.java

@@ -0,0 +1,239 @@
+package com.eactive.eai.custom.inbound.processor;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.springframework.context.ApplicationContext;
+import org.springframework.test.util.ReflectionTestUtils;
+
+import com.eactive.eai.common.inflow.Bucket;
+import com.eactive.eai.common.inflow.InflowTargetVO;
+import com.eactive.eai.common.inflow.dual.ClientDualBucket;
+import com.eactive.eai.common.inflow.dual.DualBucket;
+import com.eactive.eai.common.inflow.dual.DualCustomBucket;
+import com.eactive.eai.common.server.EAIServerManager;
+import com.eactive.eai.common.util.ApplicationContextProvider;
+
+/**
+ * DJBRequestProcessor 단위 테스트.
+ *
+ * <p>RequestProcessor 클래스는 static 초기화 블록에서 EAIServerManager.getInstance()를 호출한다.
+ * @BeforeAll에서 mock ApplicationContext를 주입한 뒤 DJBRequestProcessor를 최초 로딩시킨다.
+ *
+ * <p>주의: DJBRequestProcessor를 필드 타입으로 선언하면 테스트 클래스 로딩 시 함께 로딩되어
+ * @BeforeAll 실행 전에 NPE가 발생한다. 반드시 메서드 본문 내에서만 참조해야 한다.
+ */
+class DJBRequestProcessorTest {
+
+    @BeforeAll
+    static void setupMockApplicationContext() {
+        ApplicationContext mockContext = mock(ApplicationContext.class);
+        EAIServerManager mockServerManager = mock(EAIServerManager.class);
+        when(mockContext.getBean(EAIServerManager.class)).thenReturn(mockServerManager);
+        when(mockServerManager.getLocalServerName()).thenReturn("TEST-SERVER");
+        when(mockServerManager.getGroupInstId()).thenReturn("TEST-INST");
+
+        ReflectionTestUtils.setField(ApplicationContextProvider.class, "context", mockContext);
+    }
+
+    private InflowTargetVO makeVO(String name, long perSec, long threshold, String unit) {
+        InflowTargetVO vo = new InflowTargetVO();
+        vo.setName(name);
+        vo.setThresholdPerSecond(perSec);
+        vo.setThreshold(threshold);
+        vo.setThresholdTimeUnit(unit);
+        vo.setActivate(true);
+        return vo;
+    }
+
+    // -------------------------------------------------------------------------
+    // checkAdapterInflow
+    // -------------------------------------------------------------------------
+
+    @Test
+    void checkAdapterInflow_dualBucket_pass_returnsNull() {
+        DJBRequestProcessor processor = new DJBRequestProcessor();
+        DualBucket mockBucket = mock(DualBucket.class);
+        when(mockBucket.isAdapterPassDetail("ADAPTER_A")).thenReturn(null);
+
+        assertNull(processor.checkAdapterInflow(mockBucket, "ADAPTER_A"));
+        verify(mockBucket).isAdapterPassDetail("ADAPTER_A");
+    }
+
+    @Test
+    void checkAdapterInflow_dualBucket_blockedPerSecond() {
+        DJBRequestProcessor processor = new DJBRequestProcessor();
+        DualBucket mockBucket = mock(DualBucket.class);
+        when(mockBucket.isAdapterPassDetail("ADAPTER_A")).thenReturn(DualCustomBucket.RESULT_BLOCKED_PER_SECOND);
+
+        assertEquals(DualCustomBucket.RESULT_BLOCKED_PER_SECOND,
+                processor.checkAdapterInflow(mockBucket, "ADAPTER_A"));
+    }
+
+    @Test
+    void checkAdapterInflow_dualBucket_blockedThreshold() {
+        DJBRequestProcessor processor = new DJBRequestProcessor();
+        DualBucket mockBucket = mock(DualBucket.class);
+        when(mockBucket.isAdapterPassDetail("ADAPTER_A")).thenReturn(DualCustomBucket.RESULT_BLOCKED_THRESHOLD);
+
+        assertEquals(DualCustomBucket.RESULT_BLOCKED_THRESHOLD,
+                processor.checkAdapterInflow(mockBucket, "ADAPTER_A"));
+    }
+
+    @Test
+    void checkAdapterInflow_nonDualBucket_pass_returnsNull() {
+        DJBRequestProcessor processor = new DJBRequestProcessor();
+        Bucket mockBucket = mock(Bucket.class);
+        when(mockBucket.isAdapterPass("ADAPTER_A")).thenReturn(true);
+
+        assertNull(processor.checkAdapterInflow(mockBucket, "ADAPTER_A"));
+    }
+
+    @Test
+    void checkAdapterInflow_nonDualBucket_blocked_returnsBlocked() {
+        DJBRequestProcessor processor = new DJBRequestProcessor();
+        Bucket mockBucket = mock(Bucket.class);
+        when(mockBucket.isAdapterPass("ADAPTER_A")).thenReturn(false);
+
+        assertEquals("BLOCKED", processor.checkAdapterInflow(mockBucket, "ADAPTER_A"));
+    }
+
+    // -------------------------------------------------------------------------
+    // checkInterfaceInflow
+    // -------------------------------------------------------------------------
+
+    @Test
+    void checkInterfaceInflow_dualBucket_pass_returnsNull() {
+        DJBRequestProcessor processor = new DJBRequestProcessor();
+        DualBucket mockBucket = mock(DualBucket.class);
+        when(mockBucket.isInterfacePassDetail("IF_001")).thenReturn(null);
+
+        assertNull(processor.checkInterfaceInflow(mockBucket, "IF_001"));
+        verify(mockBucket).isInterfacePassDetail("IF_001");
+    }
+
+    @Test
+    void checkInterfaceInflow_dualBucket_blockedPerSecond() {
+        DJBRequestProcessor processor = new DJBRequestProcessor();
+        DualBucket mockBucket = mock(DualBucket.class);
+        when(mockBucket.isInterfacePassDetail("IF_001")).thenReturn(DualCustomBucket.RESULT_BLOCKED_PER_SECOND);
+
+        assertEquals(DualCustomBucket.RESULT_BLOCKED_PER_SECOND,
+                processor.checkInterfaceInflow(mockBucket, "IF_001"));
+    }
+
+    @Test
+    void checkInterfaceInflow_nonDualBucket_pass_returnsNull() {
+        DJBRequestProcessor processor = new DJBRequestProcessor();
+        Bucket mockBucket = mock(Bucket.class);
+        when(mockBucket.isInterfacePass("IF_001")).thenReturn(true);
+
+        assertNull(processor.checkInterfaceInflow(mockBucket, "IF_001"));
+    }
+
+    @Test
+    void checkInterfaceInflow_nonDualBucket_blocked_returnsBlocked() {
+        DJBRequestProcessor processor = new DJBRequestProcessor();
+        Bucket mockBucket = mock(Bucket.class);
+        when(mockBucket.isInterfacePass("IF_001")).thenReturn(false);
+
+        assertEquals("BLOCKED", processor.checkInterfaceInflow(mockBucket, "IF_001"));
+    }
+
+    // -------------------------------------------------------------------------
+    // checkClientInflow — ClientDualBucket 기반
+    // -------------------------------------------------------------------------
+
+    @Test
+    void checkClientInflow_clientDualBucket_pass_returnsNull() {
+        DJBRequestProcessor processor = new DJBRequestProcessor();
+        ClientDualBucket mockBucket = mock(ClientDualBucket.class);
+        when(mockBucket.isClientPassDetail("CLIENT_A")).thenReturn(null);
+
+        assertNull(processor.checkClientInflow(mockBucket, "CLIENT_A"));
+        verify(mockBucket).isClientPassDetail("CLIENT_A");
+    }
+
+    @Test
+    void checkClientInflow_clientDualBucket_blocked() {
+        DJBRequestProcessor processor = new DJBRequestProcessor();
+        ClientDualBucket mockBucket = mock(ClientDualBucket.class);
+        when(mockBucket.isClientPassDetail("CLIENT_A")).thenReturn(DualCustomBucket.RESULT_BLOCKED_THRESHOLD);
+
+        assertEquals(DualCustomBucket.RESULT_BLOCKED_THRESHOLD,
+                processor.checkClientInflow(mockBucket, "CLIENT_A"));
+    }
+
+    @Test
+    void checkClientInflow_nonClientDualBucket_returnsNull() {
+        DJBRequestProcessor processor = new DJBRequestProcessor();
+        Bucket mockBucket = mock(Bucket.class);
+
+        assertNull(processor.checkClientInflow(mockBucket, "CLIENT_A"));
+    }
+
+    @Test
+    void checkClientInflow_blankClientId_returnsNull() {
+        DJBRequestProcessor processor = new DJBRequestProcessor();
+        ClientDualBucket mockBucket = mock(ClientDualBucket.class);
+
+        assertNull(processor.checkClientInflow(mockBucket, ""));
+        verify(mockBucket, never()).isClientPassDetail(any());
+    }
+
+    // -------------------------------------------------------------------------
+    // buildInflowTargetErrorMsg
+    // -------------------------------------------------------------------------
+
+    @Test
+    void buildInflowTargetErrorMsg_perSecond_includesReqPerSec() {
+        DJBRequestProcessor processor = new DJBRequestProcessor();
+        InflowTargetVO vo = makeVO("결제API", 30, 1000, "MIN");
+
+        String msg = processor.buildInflowTargetErrorMsg(vo, DualCustomBucket.RESULT_BLOCKED_PER_SECOND);
+
+        assertEquals("API 호출 한도 초과 [결제API: 30req/sec]", msg);
+    }
+
+    @Test
+    void buildInflowTargetErrorMsg_threshold_includesReqPerUnit() {
+        DJBRequestProcessor processor = new DJBRequestProcessor();
+        InflowTargetVO vo = makeVO("결제API", 30, 1000, "MIN");
+
+        String msg = processor.buildInflowTargetErrorMsg(vo, DualCustomBucket.RESULT_BLOCKED_THRESHOLD);
+
+        assertEquals("API 호출 한도 초과 [결제API: 1000req/MIN]", msg);
+    }
+
+    @Test
+    void buildInflowTargetErrorMsg_blockedFallback_simpleFormat() {
+        DJBRequestProcessor processor = new DJBRequestProcessor();
+        InflowTargetVO vo = makeVO("결제API", 30, 1000, "MIN");
+
+        String msg = processor.buildInflowTargetErrorMsg(vo, "BLOCKED");
+
+        assertEquals("API 호출 한도 초과 [결제API]", msg);
+    }
+
+    @Test
+    void buildInflowTargetErrorMsg_nullBlockedType_simpleFormat() {
+        DJBRequestProcessor processor = new DJBRequestProcessor();
+        InflowTargetVO vo = makeVO("결제API", 30, 1000, "MIN");
+
+        String msg = processor.buildInflowTargetErrorMsg(vo, null);
+
+        assertEquals("API 호출 한도 초과 [결제API]", msg);
+    }
+
+    @Test
+    void buildInflowTargetErrorMsg_hourUnit() {
+        DJBRequestProcessor processor = new DJBRequestProcessor();
+        InflowTargetVO vo = makeVO("조회API", 10, 500, "HOUR");
+
+        String msg = processor.buildInflowTargetErrorMsg(vo, DualCustomBucket.RESULT_BLOCKED_THRESHOLD);
+
+        assertEquals("API 호출 한도 초과 [조회API: 500req/HOUR]", msg);
+    }
+}

src/test/java/com/eactive/eai/custom/inflow/ClientInflowTargetBucketControllerTest.java

@@ -0,0 +1,106 @@
+package com.eactive.eai.custom.inflow;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.http.ResponseEntity;
+import org.springframework.test.util.ReflectionTestUtils;
+
+import com.eactive.eai.manage.inflow.TargetBucketStatusDTO;
+
+/**
+ * ClientInflowTargetBucketController 단위 테스트.
+ */
+class ClientInflowTargetBucketControllerTest {
+
+    private ClientInflowTargetBucketController controller;
+    private ClientInflowTargetBucketService mockService;
+
+    @BeforeEach
+    void setUp() {
+        controller  = new ClientInflowTargetBucketController();
+        mockService = mock(ClientInflowTargetBucketService.class);
+        ReflectionTestUtils.setField(controller, "bucketService", mockService);
+    }
+
+    private TargetBucketStatusDTO makeDTO(String id, String type) {
+        TargetBucketStatusDTO dto = new TargetBucketStatusDTO();
+        dto.setTargetId(id);
+        dto.setTargetType(type);
+        dto.setActivate(true);
+        dto.setBuckets(Collections.emptyList());
+        return dto;
+    }
+
+    @SuppressWarnings("unchecked")
+    private Map<String, Object> body(ResponseEntity<?> response) {
+        return (Map<String, Object>) response.getBody();
+    }
+
+    // =========================================================================
+    // 단일 조회
+    // =========================================================================
+
+    @Test
+    void getClientBucketStatus_found_successTrueAndDataPresent() {
+        TargetBucketStatusDTO dto = makeDTO("CLIENT_A", "CLIENT");
+        when(mockService.getClientBucketStatus("CLIENT_A")).thenReturn(dto);
+
+        ResponseEntity<?> response = controller.getClientBucketStatus("CLIENT_A");
+        Map<String, Object> body = body(response);
+
+        assertEquals(200, response.getStatusCodeValue());
+        assertEquals(Boolean.TRUE, body.get("success"));
+        assertSame(dto, body.get("data"));
+        assertFalse(body.containsKey("message"));
+    }
+
+    @Test
+    void getClientBucketStatus_notFound_successFalseWithClientId() {
+        when(mockService.getClientBucketStatus("CLIENT_X")).thenReturn(null);
+
+        ResponseEntity<?> response = controller.getClientBucketStatus("CLIENT_X");
+        Map<String, Object> body = body(response);
+
+        assertEquals(Boolean.FALSE, body.get("success"));
+        assertTrue(body.get("message").toString().contains("CLIENT_X"));
+    }
+
+    // =========================================================================
+    // 전체 조회
+    // =========================================================================
+
+    @Test
+    void getAllClientBucketStatus_returnsListAndCount() {
+        List<TargetBucketStatusDTO> list = Arrays.asList(
+                makeDTO("CLIENT_A", "CLIENT"),
+                makeDTO("CLIENT_B", "CLIENT"),
+                makeDTO("CLIENT_C", "CLIENT")
+        );
+        when(mockService.getAllClientBucketStatus()).thenReturn(list);
+
+        ResponseEntity<?> response = controller.getAllClientBucketStatus();
+        Map<String, Object> body = body(response);
+
+        assertEquals(Boolean.TRUE, body.get("success"));
+        assertSame(list, body.get("data"));
+        assertEquals(3, body.get("count"));
+    }
+
+    @Test
+    void getAllClientBucketStatus_emptyList_countZero() {
+        when(mockService.getAllClientBucketStatus()).thenReturn(Collections.emptyList());
+
+        Map<String, Object> body = body(controller.getAllClientBucketStatus());
+
+        assertEquals(Boolean.TRUE, body.get("success"));
+        assertEquals(0, body.get("count"));
+    }
+}

src/test/java/com/eactive/eai/custom/inflow/ClientInflowTargetBucketServiceTest.java

@@ -0,0 +1,208 @@
+package com.eactive.eai.custom.inflow;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.time.Duration;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.junit.jupiter.api.Test;
+
+import com.eactive.eai.common.inflow.InflowTargetVO;
+import com.eactive.eai.common.inflow.dual.ClientDualInflowControlManager;
+import com.eactive.eai.common.inflow.dual.DualCustomBucket;
+import com.eactive.eai.manage.inflow.GroupBucketStatusDTO;
+import com.eactive.eai.manage.inflow.TargetBucketStatusDTO;
+
+import io.github.bucket4j.Bandwidth;
+import io.github.bucket4j.Bucket4j;
+import io.github.bucket4j.local.LocalBucket;
+
+/**
+ * ClientInflowTargetBucketService 단위 테스트.
+ */
+class ClientInflowTargetBucketServiceTest {
+
+    // -------------------------------------------------------------------------
+    // 테스트용 서브클래스
+    // -------------------------------------------------------------------------
+
+    private static ClientInflowTargetBucketService serviceWith(ClientDualInflowControlManager manager) {
+        return new ClientInflowTargetBucketService() {
+            @Override
+            protected ClientDualInflowControlManager getClientDualManager() { return manager; }
+        };
+    }
+
+    // -------------------------------------------------------------------------
+    // Helpers
+    // -------------------------------------------------------------------------
+
+    private InflowTargetVO makeVO(String name, long perSec, long threshold, String unit, boolean activate) {
+        InflowTargetVO vo = new InflowTargetVO();
+        vo.setName(name);
+        vo.setThresholdPerSecond(perSec);
+        vo.setThreshold(threshold);
+        vo.setThresholdTimeUnit(unit);
+        vo.setActivate(activate);
+        return vo;
+    }
+
+    private LocalBucket freshBucket(long capacity) {
+        return Bucket4j.builder()
+                .addLimit(Bandwidth.simple(capacity, Duration.ofSeconds(1)))
+                .build();
+    }
+
+    private LocalBucket exhaustedBucket(long capacity) {
+        LocalBucket b = freshBucket(capacity);
+        b.tryConsume(capacity);
+        return b;
+    }
+
+    private DualCustomBucket makeDualBucket(String name, long perSec, long threshold) {
+        return new DualCustomBucket(freshBucket(perSec), freshBucket(threshold),
+                makeVO(name, perSec, threshold, "DAY", true));
+    }
+
+    // =========================================================================
+    // ClientDualManager null (비활성 환경)
+    // =========================================================================
+
+    @Test
+    void getClientBucketStatus_managerIsNull_returnsNull() {
+        assertNull(serviceWith(null).getClientBucketStatus("CLIENT_A"));
+    }
+
+    @Test
+    void getAllClientBucketStatus_managerIsNull_returnsEmptyList() {
+        assertTrue(serviceWith(null).getAllClientBucketStatus().isEmpty());
+    }
+
+    // =========================================================================
+    // 버킷 미존재
+    // =========================================================================
+
+    @Test
+    void getClientBucketStatus_notFound_returnsNull() {
+        ClientDualInflowControlManager manager = mock(ClientDualInflowControlManager.class);
+        when(manager.getClientBucket("CLIENT_A")).thenReturn(null);
+
+        assertNull(serviceWith(manager).getClientBucketStatus("CLIENT_A"));
+    }
+
+    // =========================================================================
+    // 단일 조회 — targetType, targetId 매핑
+    // =========================================================================
+
+    @Test
+    void getClientBucketStatus_found_mapsClientType() {
+        ClientDualInflowControlManager manager = mock(ClientDualInflowControlManager.class);
+        when(manager.getClientBucket("CLIENT_A")).thenReturn(makeDualBucket("CLIENT_A", 50, 5000));
+
+        TargetBucketStatusDTO dto = serviceWith(manager).getClientBucketStatus("CLIENT_A");
+
+        assertNotNull(dto);
+        assertEquals("CLIENT_A", dto.getTargetId());
+        assertEquals("CLIENT", dto.getTargetType());
+        assertTrue(dto.isActivate());
+        assertEquals(2, dto.getBuckets().size());
+    }
+
+    // =========================================================================
+    // BucketInfo 타입별 포함 여부
+    // =========================================================================
+
+    @Test
+    void toDto_onlyThreshold_bucketInfoHasOneThresholdEntry() {
+        InflowTargetVO vo = makeVO("C1", 0, 1000, "DAY", true);
+        DualCustomBucket bucket = new DualCustomBucket(null, freshBucket(1000), vo);
+
+        ClientDualInflowControlManager manager = mock(ClientDualInflowControlManager.class);
+        when(manager.getClientBucket("C1")).thenReturn(bucket);
+
+        TargetBucketStatusDTO dto = serviceWith(manager).getClientBucketStatus("C1");
+
+        assertEquals(1, dto.getBuckets().size());
+        assertEquals("threshold", dto.getBuckets().get(0).getType());
+    }
+
+    @Test
+    void toDto_onlyPerSecond_bucketInfoHasOnePerSecondEntry() {
+        InflowTargetVO vo = makeVO("C2", 100, 0, null, true);
+        DualCustomBucket bucket = new DualCustomBucket(freshBucket(100), null, vo);
+
+        ClientDualInflowControlManager manager = mock(ClientDualInflowControlManager.class);
+        when(manager.getClientBucket("C2")).thenReturn(bucket);
+
+        TargetBucketStatusDTO dto = serviceWith(manager).getClientBucketStatus("C2");
+
+        assertEquals(1, dto.getBuckets().size());
+        assertEquals("perSecond", dto.getBuckets().get(0).getType());
+    }
+
+    @Test
+    void toDto_bothBuckets_bucketInfoHasTwoEntries() {
+        ClientDualInflowControlManager manager = mock(ClientDualInflowControlManager.class);
+        when(manager.getClientBucket("C3")).thenReturn(makeDualBucket("C3", 100, 5000));
+
+        TargetBucketStatusDTO dto = serviceWith(manager).getClientBucketStatus("C3");
+
+        assertEquals(2, dto.getBuckets().size());
+        assertEquals("perSecond", dto.getBuckets().get(0).getType());
+        assertEquals("threshold", dto.getBuckets().get(1).getType());
+    }
+
+    // =========================================================================
+    // 사용률 계산
+    // =========================================================================
+
+    @Test
+    void toDto_exhaustedThreshold_usagePercentIs100() {
+        InflowTargetVO vo = makeVO("C4", 0, 100, "DAY", true);
+        DualCustomBucket bucket = new DualCustomBucket(null, exhaustedBucket(100), vo);
+
+        ClientDualInflowControlManager manager = mock(ClientDualInflowControlManager.class);
+        when(manager.getClientBucket("C4")).thenReturn(bucket);
+
+        TargetBucketStatusDTO dto = serviceWith(manager).getClientBucketStatus("C4");
+
+        GroupBucketStatusDTO.BucketInfo info = dto.getBuckets().get(0);
+        assertEquals(0, info.getAvailableTokens());
+        assertEquals(100.0, info.getUsagePercent(), 0.01);
+    }
+
+    @Test
+    void toDto_freshBucket_usagePercentIsZero() {
+        InflowTargetVO vo = makeVO("C5", 0, 100, "DAY", true);
+        DualCustomBucket bucket = new DualCustomBucket(null, freshBucket(100), vo);
+
+        ClientDualInflowControlManager manager = mock(ClientDualInflowControlManager.class);
+        when(manager.getClientBucket("C5")).thenReturn(bucket);
+
+        TargetBucketStatusDTO dto = serviceWith(manager).getClientBucketStatus("C5");
+
+        GroupBucketStatusDTO.BucketInfo info = dto.getBuckets().get(0);
+        assertEquals(100, info.getAvailableTokens());
+        assertEquals(0.0, info.getUsagePercent(), 0.01);
+    }
+
+    // =========================================================================
+    // 전체 목록 조회
+    // =========================================================================
+
+    @Test
+    void getAllClientBucketStatus_twoEntries_returnsBoth() {
+        ClientDualInflowControlManager manager = mock(ClientDualInflowControlManager.class);
+        Map<String, DualCustomBucket> map = new ConcurrentHashMap<>();
+        map.put("CLIENT_A", makeDualBucket("CLIENT_A", 10, 1000));
+        map.put("CLIENT_B", makeDualBucket("CLIENT_B", 20, 2000));
+        when(manager.getClientBucketMap()).thenReturn(map);
+
+        List<TargetBucketStatusDTO> result = serviceWith(manager).getAllClientBucketStatus();
+
+        assertEquals(2, result.size());
+    }
+}

src/test/java/com/eactive/eai/custom/inflow/ClientInflowTargetMetricControllerTest.java

@@ -0,0 +1,144 @@
+package com.eactive.eai.custom.inflow;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.http.ResponseEntity;
+import org.springframework.test.util.ReflectionTestUtils;
+
+import com.eactive.eai.manage.inflow.TargetMetricDTO;
+
+/**
+ * ClientInflowTargetMetricController 단위 테스트.
+ *
+ * <p>Spring MVC를 기동하지 않고 컨트롤러를 직접 인스턴스화하여
+ * 응답 구조(success, data, count, message)를 검증한다.
+ */
+class ClientInflowTargetMetricControllerTest {
+
+    private ClientInflowTargetMetricController controller;
+    private ClientInflowTargetMetricService mockService;
+
+    @BeforeEach
+    void setUp() {
+        controller  = new ClientInflowTargetMetricController();
+        mockService = mock(ClientInflowTargetMetricService.class);
+        ReflectionTestUtils.setField(controller, "metricService", mockService);
+    }
+
+    private TargetMetricDTO makeDTO(String targetId, String targetType,
+                                    long allowed, long rejPs, long rejTh) {
+        TargetMetricDTO dto = new TargetMetricDTO();
+        dto.setTargetId(targetId);
+        dto.setTargetType(targetType);
+        dto.setActivate(true);
+        dto.setAllowed(allowed);
+        dto.setRejectedPerSecond(rejPs);
+        dto.setRejectedThreshold(rejTh);
+        long total = allowed + rejPs + rejTh;
+        dto.setTotalRequests(total);
+        dto.setRejectRatio(total > 0 ? (double)(rejPs + rejTh) / total * 100 : 0.0);
+        return dto;
+    }
+
+    @SuppressWarnings("unchecked")
+    private Map<String, Object> body(ResponseEntity<?> response) {
+        return (Map<String, Object>) response.getBody();
+    }
+
+    // =========================================================================
+    // 단일 조회
+    // =========================================================================
+
+    @Test
+    void getClientMetric_found_successTrueAndDataPresent() {
+        TargetMetricDTO dto = makeDTO("C1", "CLIENT", 300, 50, 20);
+        when(mockService.getClientMetric("C1")).thenReturn(dto);
+
+        Map<String, Object> body = body(controller.getClientMetric("C1"));
+
+        assertEquals(Boolean.TRUE, body.get("success"));
+        assertSame(dto, body.get("data"));
+        assertFalse(body.containsKey("message"));
+    }
+
+    @Test
+    void getClientMetric_notFound_successFalseWithMessage() {
+        when(mockService.getClientMetric("GHOST")).thenReturn(null);
+
+        Map<String, Object> body = body(controller.getClientMetric("GHOST"));
+
+        assertEquals(Boolean.FALSE, body.get("success"));
+        assertTrue(body.get("message").toString().contains("GHOST"));
+    }
+
+    // =========================================================================
+    // 전체 조회
+    // =========================================================================
+
+    @Test
+    void getAllClientMetrics_returnsListAndCount() {
+        List<TargetMetricDTO> list = Arrays.asList(
+            makeDTO("C1", "CLIENT", 100, 5, 5),
+            makeDTO("C2", "CLIENT", 200, 0, 0),
+            makeDTO("C3", "CLIENT", 50,  10, 0)
+        );
+        when(mockService.getAllClientMetrics()).thenReturn(list);
+
+        Map<String, Object> body = body(controller.getAllClientMetrics());
+
+        assertEquals(Boolean.TRUE, body.get("success"));
+        assertSame(list, body.get("data"));
+        assertEquals(3, body.get("count"));
+    }
+
+    @Test
+    void getAllClientMetrics_emptyList_countZero() {
+        when(mockService.getAllClientMetrics()).thenReturn(Collections.emptyList());
+
+        Map<String, Object> body = body(controller.getAllClientMetrics());
+
+        assertEquals(Boolean.TRUE, body.get("success"));
+        assertEquals(0, body.get("count"));
+    }
+
+    // =========================================================================
+    // reset
+    // =========================================================================
+
+    @Test
+    void resetClientMetric_success_successTrueWithTargetId() {
+        when(mockService.resetClientMetric("C1")).thenReturn(true);
+
+        Map<String, Object> body = body(controller.resetClientMetric("C1"));
+
+        assertEquals(Boolean.TRUE, body.get("success"));
+        assertTrue(body.get("message").toString().contains("C1"));
+    }
+
+    @Test
+    void resetClientMetric_notFound_successFalseWithTargetId() {
+        when(mockService.resetClientMetric("GHOST")).thenReturn(false);
+
+        Map<String, Object> body = body(controller.resetClientMetric("GHOST"));
+
+        assertEquals(Boolean.FALSE, body.get("success"));
+        assertTrue(body.get("message").toString().contains("GHOST"));
+    }
+
+    @Test
+    void resetAllClientMetrics_callsDelegateOnce() {
+        doNothing().when(mockService).resetAllClientMetrics();
+
+        controller.resetAllClientMetrics();
+
+        verify(mockService, times(1)).resetAllClientMetrics();
+    }
+}

src/test/java/com/eactive/eai/custom/inflow/ClientInflowTargetMetricServiceTest.java

@@ -0,0 +1,177 @@
+package com.eactive.eai.custom.inflow;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+
+import com.eactive.eai.common.inflow.InflowTargetVO;
+import com.eactive.eai.common.inflow.dual.ClientDualInflowControlManager;
+import com.eactive.eai.common.inflow.dual.DualInflowControlManager;
+import com.eactive.eai.manage.inflow.TargetMetricDTO;
+
+class ClientInflowTargetMetricServiceTest {
+
+    private static ClientInflowTargetMetricService serviceWith(ClientDualInflowControlManager manager) {
+        return new ClientInflowTargetMetricService() {
+            @Override
+            protected ClientDualInflowControlManager getClientDualManager() { return manager; }
+        };
+    }
+
+    private InflowTargetVO makeVO(String name) {
+        InflowTargetVO vo = new InflowTargetVO();
+        vo.setName(name);
+        vo.setActivate(true);
+        return vo;
+    }
+
+    private DualInflowControlManager.TargetMetrics makeMetrics(long allowed, long rejPs, long rejTh) {
+        DualInflowControlManager.TargetMetrics m = new DualInflowControlManager.TargetMetrics();
+        m.allowed.set(allowed);
+        m.rejectedPerSecond.set(rejPs);
+        m.rejectedThreshold.set(rejTh);
+        return m;
+    }
+
+    // =========================================================================
+    // null 관리자 (비활성 환경)
+    // =========================================================================
+
+    @Test
+    void getClientMetric_managerIsNull_returnsNull() {
+        assertNull(serviceWith(null).getClientMetric("C1"));
+    }
+
+    @Test
+    void getAllClientMetrics_managerIsNull_returnsEmptyList() {
+        assertTrue(serviceWith(null).getAllClientMetrics().isEmpty());
+    }
+
+    @Test
+    void resetClientMetric_managerIsNull_returnsFalse() {
+        assertFalse(serviceWith(null).resetClientMetric("C1"));
+    }
+
+    @Test
+    void resetAllClientMetrics_managerIsNull_noException() {
+        assertDoesNotThrow(() -> serviceWith(null).resetAllClientMetrics());
+    }
+
+    // =========================================================================
+    // 단일 조회
+    // =========================================================================
+
+    @Test
+    void getClientMetric_found_mapsFields() {
+        ClientDualInflowControlManager manager = mock(ClientDualInflowControlManager.class);
+        when(manager.getClientInflowThreshold("C1")).thenReturn(makeVO("C1"));
+        when(manager.getClientMetrics("C1")).thenReturn(makeMetrics(200, 30, 20));
+
+        TargetMetricDTO dto = serviceWith(manager).getClientMetric("C1");
+
+        assertNotNull(dto);
+        assertEquals("C1",     dto.getTargetId());
+        assertEquals("CLIENT", dto.getTargetType());
+        assertTrue(dto.isActivate());
+        assertEquals(200, dto.getAllowed());
+        assertEquals(30,  dto.getRejectedPerSecond());
+        assertEquals(20,  dto.getRejectedThreshold());
+        assertEquals(250, dto.getTotalRequests());
+    }
+
+    @Test
+    void getClientMetric_notRegistered_returnsNull() {
+        ClientDualInflowControlManager manager = mock(ClientDualInflowControlManager.class);
+        when(manager.getClientInflowThreshold("C1")).thenReturn(null);
+
+        assertNull(serviceWith(manager).getClientMetric("C1"));
+    }
+
+    @Test
+    void getClientMetric_noMetricsYet_returnsZeroCounters() {
+        ClientDualInflowControlManager manager = mock(ClientDualInflowControlManager.class);
+        when(manager.getClientInflowThreshold("C1")).thenReturn(makeVO("C1"));
+        when(manager.getClientMetrics("C1")).thenReturn(null);
+
+        TargetMetricDTO dto = serviceWith(manager).getClientMetric("C1");
+
+        assertNotNull(dto);
+        assertEquals(0,   dto.getAllowed());
+        assertEquals(0,   dto.getTotalRequests());
+        assertEquals(0.0, dto.getRejectRatio(), 0.001);
+    }
+
+    @Test
+    void getClientMetric_rejectRatioCalculation() {
+        ClientDualInflowControlManager manager = mock(ClientDualInflowControlManager.class);
+        when(manager.getClientInflowThreshold("C1")).thenReturn(makeVO("C1"));
+        // allowed=90, rejPs=5, rejTh=5 → reject=10/100 = 10.00%
+        when(manager.getClientMetrics("C1")).thenReturn(makeMetrics(90, 5, 5));
+
+        TargetMetricDTO dto = serviceWith(manager).getClientMetric("C1");
+
+        assertEquals(10.0, dto.getRejectRatio(), 0.01);
+    }
+
+    // =========================================================================
+    // 전체 조회
+    // =========================================================================
+
+    @Test
+    void getAllClientMetrics_twoEntries_returnsBoth() {
+        ClientDualInflowControlManager manager = mock(ClientDualInflowControlManager.class);
+        java.util.Map<String, com.eactive.eai.common.inflow.dual.DualCustomBucket> bucketMap =
+            new java.util.LinkedHashMap<>();
+        bucketMap.put("C1", null);
+        bucketMap.put("C2", null);
+        when(manager.getClientBucketMap()).thenReturn(bucketMap);
+        when(manager.getClientInflowThreshold("C1")).thenReturn(makeVO("C1"));
+        when(manager.getClientInflowThreshold("C2")).thenReturn(makeVO("C2"));
+        when(manager.getClientMetrics("C1")).thenReturn(makeMetrics(10, 0, 0));
+        when(manager.getClientMetrics("C2")).thenReturn(makeMetrics(20, 5, 0));
+
+        List<TargetMetricDTO> result = serviceWith(manager).getAllClientMetrics();
+
+        assertEquals(2, result.size());
+    }
+
+    @Test
+    void getAllClientMetrics_noKeys_returnsEmptyList() {
+        ClientDualInflowControlManager manager = mock(ClientDualInflowControlManager.class);
+        when(manager.getClientBucketMap()).thenReturn(new java.util.HashMap<>());
+
+        assertTrue(serviceWith(manager).getAllClientMetrics().isEmpty());
+    }
+
+    // =========================================================================
+    // reset
+    // =========================================================================
+
+    @Test
+    void resetClientMetric_success_returnsTrueAndCallsManager() {
+        ClientDualInflowControlManager manager = mock(ClientDualInflowControlManager.class);
+        when(manager.getClientInflowThreshold("C1")).thenReturn(makeVO("C1"));
+
+        assertTrue(serviceWith(manager).resetClientMetric("C1"));
+        verify(manager).resetClientMetrics("C1");
+    }
+
+    @Test
+    void resetClientMetric_notRegistered_returnsFalseAndNoReset() {
+        ClientDualInflowControlManager manager = mock(ClientDualInflowControlManager.class);
+        when(manager.getClientInflowThreshold("C1")).thenReturn(null);
+
+        assertFalse(serviceWith(manager).resetClientMetric("C1"));
+        verify(manager, never()).resetClientMetrics(any());
+    }
+
+    @Test
+    void resetAllClientMetrics_callsManager() {
+        ClientDualInflowControlManager manager = mock(ClientDualInflowControlManager.class);
+        serviceWith(manager).resetAllClientMetrics();
+        verify(manager).resetAllClientMetrics();
+    }
+}

src/test/java/com/eactive/eai/manage/inflow/InflowTargetBucketControllerTest.java

@@ -0,0 +1,152 @@
+package com.eactive.eai.manage.inflow;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.http.ResponseEntity;
+import org.springframework.test.util.ReflectionTestUtils;
+
+/**
+ * InflowTargetBucketController 단위 테스트.
+ *
+ * <p>Spring MVC를 기동하지 않고 컨트롤러를 직접 인스턴스화하여
+ * 응답 구조(success, data, count, message)를 검증한다.
+ * 클라이언트 관련 테스트는 ClientInflowTargetBucketControllerTest 에서 검증한다.
+ */
+class InflowTargetBucketControllerTest {
+
+    private InflowTargetBucketController controller;
+    private InflowTargetBucketService mockService;
+
+    @BeforeEach
+    void setUp() {
+        controller  = new InflowTargetBucketController();
+        mockService = mock(InflowTargetBucketService.class);
+        ReflectionTestUtils.setField(controller, "bucketService", mockService);
+    }
+
+    // -------------------------------------------------------------------------
+    // Helper
+    // -------------------------------------------------------------------------
+
+    private TargetBucketStatusDTO makeDTO(String id, String type) {
+        TargetBucketStatusDTO dto = new TargetBucketStatusDTO();
+        dto.setTargetId(id);
+        dto.setTargetType(type);
+        dto.setActivate(true);
+        dto.setBuckets(Collections.emptyList());
+        return dto;
+    }
+
+    @SuppressWarnings("unchecked")
+    private Map<String, Object> body(ResponseEntity<?> response) {
+        return (Map<String, Object>) response.getBody();
+    }
+
+    // =========================================================================
+    // 어댑터 — 단일 조회
+    // =========================================================================
+
+    @Test
+    void getAdapterBucketStatus_found_successTrueAndDataPresent() {
+        TargetBucketStatusDTO dto = makeDTO("ADAPTER_A", "ADAPTER");
+        when(mockService.getAdapterBucketStatus("ADAPTER_A")).thenReturn(dto);
+
+        ResponseEntity<?> response = controller.getAdapterBucketStatus("ADAPTER_A");
+        Map<String, Object> body = body(response);
+
+        assertEquals(200, response.getStatusCodeValue());
+        assertEquals(Boolean.TRUE, body.get("success"));
+        assertSame(dto, body.get("data"));
+        assertFalse(body.containsKey("message"));
+    }
+
+    @Test
+    void getAdapterBucketStatus_notFound_successFalseWithAdapterId() {
+        when(mockService.getAdapterBucketStatus("GHOST")).thenReturn(null);
+
+        ResponseEntity<?> response = controller.getAdapterBucketStatus("GHOST");
+        Map<String, Object> body = body(response);
+
+        assertEquals(Boolean.FALSE, body.get("success"));
+        assertTrue(body.get("message").toString().contains("GHOST"));
+    }
+
+    // =========================================================================
+    // 어댑터 — 전체 조회
+    // =========================================================================
+
+    @Test
+    void getAllAdapterBucketStatus_returnsListAndCount() {
+        List<TargetBucketStatusDTO> list = Arrays.asList(
+                makeDTO("A1", "ADAPTER"),
+                makeDTO("A2", "ADAPTER")
+        );
+        when(mockService.getAllAdapterBucketStatus()).thenReturn(list);
+
+        ResponseEntity<?> response = controller.getAllAdapterBucketStatus();
+        Map<String, Object> body = body(response);
+
+        assertEquals(Boolean.TRUE, body.get("success"));
+        assertSame(list, body.get("data"));
+        assertEquals(2, body.get("count"));
+    }
+
+    @Test
+    void getAllAdapterBucketStatus_emptyList_countZero() {
+        when(mockService.getAllAdapterBucketStatus()).thenReturn(Collections.emptyList());
+
+        Map<String, Object> body = body(controller.getAllAdapterBucketStatus());
+
+        assertEquals(Boolean.TRUE, body.get("success"));
+        assertEquals(0, body.get("count"));
+    }
+
+    // =========================================================================
+    // 인터페이스 — 단일 조회
+    // =========================================================================
+
+    @Test
+    void getInterfaceBucketStatus_found_successTrue() {
+        TargetBucketStatusDTO dto = makeDTO("IF_001", "INTERFACE");
+        when(mockService.getInterfaceBucketStatus("IF_001")).thenReturn(dto);
+
+        ResponseEntity<?> response = controller.getInterfaceBucketStatus("IF_001");
+        Map<String, Object> body = body(response);
+
+        assertEquals(Boolean.TRUE, body.get("success"));
+        assertSame(dto, body.get("data"));
+    }
+
+    @Test
+    void getInterfaceBucketStatus_notFound_successFalseWithInterfaceId() {
+        when(mockService.getInterfaceBucketStatus("GHOST")).thenReturn(null);
+
+        Map<String, Object> body = body(controller.getInterfaceBucketStatus("GHOST"));
+
+        assertEquals(Boolean.FALSE, body.get("success"));
+        assertTrue(body.get("message").toString().contains("GHOST"));
+    }
+
+    // =========================================================================
+    // 인터페이스 — 전체 조회
+    // =========================================================================
+
+    @Test
+    void getAllInterfaceBucketStatus_returnsListAndCount() {
+        List<TargetBucketStatusDTO> list = Collections.singletonList(makeDTO("IF_001", "INTERFACE"));
+        when(mockService.getAllInterfaceBucketStatus()).thenReturn(list);
+
+        Map<String, Object> body = body(controller.getAllInterfaceBucketStatus());
+
+        assertEquals(Boolean.TRUE, body.get("success"));
+        assertEquals(1, body.get("count"));
+    }
+}

src/test/java/com/eactive/eai/manage/inflow/InflowTargetBucketServiceTest.java

@@ -0,0 +1,194 @@
+package com.eactive.eai.manage.inflow;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.time.Duration;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.junit.jupiter.api.Test;
+
+import com.eactive.eai.common.inflow.InflowTargetVO;
+import com.eactive.eai.common.inflow.dual.DualCustomBucket;
+import com.eactive.eai.common.inflow.dual.DualInflowControlManager;
+
+import io.github.bucket4j.Bandwidth;
+import io.github.bucket4j.Bucket4j;
+import io.github.bucket4j.local.LocalBucket;
+
+/**
+ * InflowTargetBucketService 단위 테스트.
+ *
+ * <p>어댑터/인터페이스: getDualManager()를 오버라이드하는 서브클래스 사용.
+ * 클라이언트 관련 테스트는 ClientInflowTargetBucketServiceTest 에서 검증한다.
+ */
+class InflowTargetBucketServiceTest {
+
+    // -------------------------------------------------------------------------
+    // 테스트용 서브클래스
+    // -------------------------------------------------------------------------
+
+    private static InflowTargetBucketService serviceWith(DualInflowControlManager manager) {
+        return new InflowTargetBucketService() {
+            @Override
+            protected DualInflowControlManager getDualManager() { return manager; }
+        };
+    }
+
+    // -------------------------------------------------------------------------
+    // Helpers
+    // -------------------------------------------------------------------------
+
+    private InflowTargetVO makeVO(String name, long perSec, long threshold, String unit, boolean activate) {
+        InflowTargetVO vo = new InflowTargetVO();
+        vo.setName(name);
+        vo.setThresholdPerSecond(perSec);
+        vo.setThreshold(threshold);
+        vo.setThresholdTimeUnit(unit);
+        vo.setActivate(activate);
+        return vo;
+    }
+
+    private LocalBucket freshBucket(long capacity) {
+        return Bucket4j.builder()
+                .addLimit(Bandwidth.simple(capacity, Duration.ofSeconds(1)))
+                .build();
+    }
+
+    private LocalBucket exhaustedBucket(long capacity) {
+        LocalBucket b = freshBucket(capacity);
+        b.tryConsume(capacity);
+        return b;
+    }
+
+    private DualCustomBucket makeDualBucket(String name, long perSec, long threshold) {
+        return new DualCustomBucket(freshBucket(perSec), freshBucket(threshold),
+                makeVO(name, perSec, threshold, "DAY", true));
+    }
+
+    // =========================================================================
+    // DualManager null (비활성 환경)
+    // =========================================================================
+
+    @Test
+    void getAdapterBucketStatus_managerIsNull_returnsNull() {
+        assertNull(serviceWith(null).getAdapterBucketStatus("ADAPTER_A"));
+    }
+
+    @Test
+    void getAllAdapterBucketStatus_managerIsNull_returnsEmptyList() {
+        List<TargetBucketStatusDTO> result = serviceWith(null).getAllAdapterBucketStatus();
+        assertNotNull(result);
+        assertTrue(result.isEmpty());
+    }
+
+    @Test
+    void getInterfaceBucketStatus_managerIsNull_returnsNull() {
+        assertNull(serviceWith(null).getInterfaceBucketStatus("IF_001"));
+    }
+
+    @Test
+    void getAllInterfaceBucketStatus_managerIsNull_returnsEmptyList() {
+        assertTrue(serviceWith(null).getAllInterfaceBucketStatus().isEmpty());
+    }
+
+    // =========================================================================
+    // 버킷 미존재
+    // =========================================================================
+
+    @Test
+    void getAdapterBucketStatus_notFound_returnsNull() {
+        DualInflowControlManager manager = mock(DualInflowControlManager.class);
+        when(manager.getAdapterBucket("ADAPTER_A")).thenReturn(null);
+
+        assertNull(serviceWith(manager).getAdapterBucketStatus("ADAPTER_A"));
+    }
+
+    @Test
+    void getInterfaceBucketStatus_notFound_returnsNull() {
+        DualInflowControlManager manager = mock(DualInflowControlManager.class);
+        when(manager.getInterfaceBucket("IF_001")).thenReturn(null);
+
+        assertNull(serviceWith(manager).getInterfaceBucketStatus("IF_001"));
+    }
+
+    // =========================================================================
+    // 단일 조회 — targetType, targetId 매핑
+    // =========================================================================
+
+    @Test
+    void getAdapterBucketStatus_found_mapsAdapterType() {
+        DualInflowControlManager manager = mock(DualInflowControlManager.class);
+        when(manager.getAdapterBucket("ADAPTER_A")).thenReturn(makeDualBucket("ADAPTER_A", 10, 1000));
+
+        TargetBucketStatusDTO dto = serviceWith(manager).getAdapterBucketStatus("ADAPTER_A");
+
+        assertNotNull(dto);
+        assertEquals("ADAPTER_A", dto.getTargetId());
+        assertEquals("ADAPTER", dto.getTargetType());
+        assertTrue(dto.isActivate());
+        assertEquals(2, dto.getBuckets().size());
+    }
+
+    @Test
+    void getInterfaceBucketStatus_found_mapsInterfaceType() {
+        DualInflowControlManager manager = mock(DualInflowControlManager.class);
+        when(manager.getInterfaceBucket("IF_001")).thenReturn(makeDualBucket("IF_001", 20, 2000));
+
+        TargetBucketStatusDTO dto = serviceWith(manager).getInterfaceBucketStatus("IF_001");
+
+        assertNotNull(dto);
+        assertEquals("IF_001", dto.getTargetId());
+        assertEquals("INTERFACE", dto.getTargetType());
+        assertTrue(dto.isActivate());
+        assertEquals(2, dto.getBuckets().size());
+    }
+
+    // =========================================================================
+    // BucketInfo 용량/시간단위 매핑
+    // =========================================================================
+
+    @Test
+    void toDto_capacity_perSecondBucketInfoCapacityMatchesVO() {
+        DualInflowControlManager manager = mock(DualInflowControlManager.class);
+        when(manager.getAdapterBucket("A1")).thenReturn(makeDualBucket("A1", 30, 3000));
+
+        TargetBucketStatusDTO dto = serviceWith(manager).getAdapterBucketStatus("A1");
+
+        GroupBucketStatusDTO.BucketInfo ps = dto.getBuckets().get(0);
+        assertEquals(30, ps.getCapacity());
+        assertEquals("SEC", ps.getTimeUnit());
+
+        GroupBucketStatusDTO.BucketInfo th = dto.getBuckets().get(1);
+        assertEquals(3000, th.getCapacity());
+        assertEquals("DAY", th.getTimeUnit());
+    }
+
+    // =========================================================================
+    // 전체 목록 조회
+    // =========================================================================
+
+    @Test
+    void getAllAdapterBucketStatus_emptyMap_returnsEmptyList() {
+        DualInflowControlManager manager = mock(DualInflowControlManager.class);
+        when(manager.getAdapterBucketMap()).thenReturn(new ConcurrentHashMap<>());
+
+        assertTrue(serviceWith(manager).getAllAdapterBucketStatus().isEmpty());
+    }
+
+    @Test
+    void getAllInterfaceBucketStatus_oneEntry_targetTypeIsInterface() {
+        DualInflowControlManager manager = mock(DualInflowControlManager.class);
+        Map<String, DualCustomBucket> map = new ConcurrentHashMap<>();
+        map.put("IF_001", makeDualBucket("IF_001", 10, 1000));
+        when(manager.getInterfaceBucketMap()).thenReturn(map);
+
+        List<TargetBucketStatusDTO> result = serviceWith(manager).getAllInterfaceBucketStatus();
+
+        assertEquals(1, result.size());
+        assertEquals("INTERFACE", result.get(0).getTargetType());
+        assertEquals("IF_001", result.get(0).getTargetId());
+    }
+}

src/test/java/com/eactive/eai/manage/inflow/InflowTargetMetricControllerTest.java

@@ -0,0 +1,213 @@
+package com.eactive.eai.manage.inflow;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.http.ResponseEntity;
+import org.springframework.test.util.ReflectionTestUtils;
+
+/**
+ * InflowTargetMetricController 단위 테스트.
+ *
+ * <p>Spring MVC를 기동하지 않고 컨트롤러를 직접 인스턴스화하여
+ * 응답 구조(success, data, count, message)를 검증한다.
+ */
+class InflowTargetMetricControllerTest {
+
+    private InflowTargetMetricController controller;
+    private InflowTargetMetricService mockService;
+
+    @BeforeEach
+    void setUp() {
+        controller   = new InflowTargetMetricController();
+        mockService  = mock(InflowTargetMetricService.class);
+        ReflectionTestUtils.setField(controller, "metricService", mockService);
+    }
+
+    // -------------------------------------------------------------------------
+    // Helper
+    // -------------------------------------------------------------------------
+
+    private TargetMetricDTO makeDTO(String targetId, String targetType,
+                                    long allowed, long rejPs, long rejTh) {
+        TargetMetricDTO dto = new TargetMetricDTO();
+        dto.setTargetId(targetId);
+        dto.setTargetType(targetType);
+        dto.setActivate(true);
+        dto.setAllowed(allowed);
+        dto.setRejectedPerSecond(rejPs);
+        dto.setRejectedThreshold(rejTh);
+        long total = allowed + rejPs + rejTh;
+        dto.setTotalRequests(total);
+        dto.setRejectRatio(total > 0 ? (double)(rejPs + rejTh) / total * 100 : 0.0);
+        return dto;
+    }
+
+    @SuppressWarnings("unchecked")
+    private Map<String, Object> body(ResponseEntity<?> response) {
+        return (Map<String, Object>) response.getBody();
+    }
+
+    // =========================================================================
+    // 어댑터 — 단일 조회
+    // =========================================================================
+
+    @Test
+    void getAdapterMetric_found_successTrueAndDataPresent() {
+        TargetMetricDTO dto = makeDTO("A1", "ADAPTER", 900, 60, 40);
+        when(mockService.getAdapterMetric("A1")).thenReturn(dto);
+
+        ResponseEntity<?> response = controller.getAdapterMetric("A1");
+        Map<String, Object> body = body(response);
+
+        assertEquals(200, response.getStatusCodeValue());
+        assertEquals(Boolean.TRUE, body.get("success"));
+        assertSame(dto, body.get("data"));
+        assertFalse(body.containsKey("message"));
+    }
+
+    @Test
+    void getAdapterMetric_notFound_successFalseWithMessage() {
+        when(mockService.getAdapterMetric("GHOST")).thenReturn(null);
+
+        Map<String, Object> body = body(controller.getAdapterMetric("GHOST"));
+
+        assertEquals(Boolean.FALSE, body.get("success"));
+        assertTrue(body.get("message").toString().contains("GHOST"));
+    }
+
+    // =========================================================================
+    // 어댑터 — 전체 조회
+    // =========================================================================
+
+    @Test
+    void getAllAdapterMetrics_returnsListAndCount() {
+        List<TargetMetricDTO> list = Arrays.asList(
+            makeDTO("A1", "ADAPTER", 100, 5, 0),
+            makeDTO("A2", "ADAPTER", 200, 0, 10)
+        );
+        when(mockService.getAllAdapterMetrics()).thenReturn(list);
+
+        Map<String, Object> body = body(controller.getAllAdapterMetrics());
+
+        assertEquals(Boolean.TRUE, body.get("success"));
+        assertSame(list, body.get("data"));
+        assertEquals(2, body.get("count"));
+    }
+
+    @Test
+    void getAllAdapterMetrics_emptyList_countZero() {
+        when(mockService.getAllAdapterMetrics()).thenReturn(Collections.emptyList());
+
+        Map<String, Object> body = body(controller.getAllAdapterMetrics());
+
+        assertEquals(Boolean.TRUE, body.get("success"));
+        assertEquals(0, body.get("count"));
+    }
+
+    // =========================================================================
+    // 어댑터 — reset
+    // =========================================================================
+
+    @Test
+    void resetAdapterMetric_success_successTrueWithTargetId() {
+        when(mockService.resetAdapterMetric("A1")).thenReturn(true);
+
+        Map<String, Object> body = body(controller.resetAdapterMetric("A1"));
+
+        assertEquals(Boolean.TRUE, body.get("success"));
+        assertTrue(body.get("message").toString().contains("A1"));
+    }
+
+    @Test
+    void resetAdapterMetric_notFound_successFalseWithTargetId() {
+        when(mockService.resetAdapterMetric("GHOST")).thenReturn(false);
+
+        Map<String, Object> body = body(controller.resetAdapterMetric("GHOST"));
+
+        assertEquals(Boolean.FALSE, body.get("success"));
+        assertTrue(body.get("message").toString().contains("GHOST"));
+    }
+
+    @Test
+    void resetAllAdapterMetrics_alwaysSuccessTrue() {
+        doNothing().when(mockService).resetAllAdapterMetrics();
+
+        Map<String, Object> body = body(controller.resetAllAdapterMetrics());
+
+        assertEquals(Boolean.TRUE, body.get("success"));
+        assertNotNull(body.get("message"));
+        verify(mockService).resetAllAdapterMetrics();
+    }
+
+    // =========================================================================
+    // 인터페이스 — 단일 조회
+    // =========================================================================
+
+    @Test
+    void getInterfaceMetric_found_successTrueAndDataPresent() {
+        TargetMetricDTO dto = makeDTO("IF1", "INTERFACE", 500, 20, 10);
+        when(mockService.getInterfaceMetric("IF1")).thenReturn(dto);
+
+        Map<String, Object> body = body(controller.getInterfaceMetric("IF1"));
+
+        assertEquals(Boolean.TRUE, body.get("success"));
+        assertSame(dto, body.get("data"));
+    }
+
+    @Test
+    void getInterfaceMetric_notFound_successFalseWithMessage() {
+        when(mockService.getInterfaceMetric("GHOST")).thenReturn(null);
+
+        Map<String, Object> body = body(controller.getInterfaceMetric("GHOST"));
+
+        assertEquals(Boolean.FALSE, body.get("success"));
+        assertTrue(body.get("message").toString().contains("GHOST"));
+    }
+
+    // =========================================================================
+    // 인터페이스 — 전체 조회
+    // =========================================================================
+
+    @Test
+    void getAllInterfaceMetrics_returnsListAndCount() {
+        List<TargetMetricDTO> list = Collections.singletonList(
+            makeDTO("IF1", "INTERFACE", 100, 0, 0));
+        when(mockService.getAllInterfaceMetrics()).thenReturn(list);
+
+        Map<String, Object> body = body(controller.getAllInterfaceMetrics());
+
+        assertEquals(Boolean.TRUE, body.get("success"));
+        assertEquals(1, body.get("count"));
+    }
+
+    // =========================================================================
+    // 인터페이스 — reset
+    // =========================================================================
+
+    @Test
+    void resetInterfaceMetric_success_successTrue() {
+        when(mockService.resetInterfaceMetric("IF1")).thenReturn(true);
+
+        Map<String, Object> body = body(controller.resetInterfaceMetric("IF1"));
+
+        assertEquals(Boolean.TRUE, body.get("success"));
+        assertTrue(body.get("message").toString().contains("IF1"));
+    }
+
+    @Test
+    void resetAllInterfaceMetrics_callsDelegateOnce() {
+        doNothing().when(mockService).resetAllInterfaceMetrics();
+
+        controller.resetAllInterfaceMetrics();
+
+        verify(mockService, times(1)).resetAllInterfaceMetrics();
+    }
+}

src/test/java/com/eactive/eai/manage/inflow/InflowTargetMetricServiceTest.java

@@ -0,0 +1,269 @@
+package com.eactive.eai.manage.inflow;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+
+import com.eactive.eai.common.inflow.InflowTargetVO;
+import com.eactive.eai.common.inflow.dual.DualInflowControlManager;
+
+/**
+ * InflowTargetMetricService 단위 테스트.
+ *
+ * <p>어댑터/인터페이스 테스트는 getDualManager()를 오버라이드하여 DualInflowControlManager 주입.
+ */
+class InflowTargetMetricServiceTest {
+
+    // -------------------------------------------------------------------------
+    // 테스트용 서브클래스 — 어댑터/인터페이스용
+    // -------------------------------------------------------------------------
+
+    private static InflowTargetMetricService serviceWith(DualInflowControlManager manager) {
+        return new InflowTargetMetricService() {
+            @Override
+            protected DualInflowControlManager getDualManager() { return manager; }
+        };
+    }
+
+    // -------------------------------------------------------------------------
+    // Helpers
+    // -------------------------------------------------------------------------
+
+    private InflowTargetVO makeVO(String name) {
+        InflowTargetVO vo = new InflowTargetVO();
+        vo.setName(name);
+        vo.setActivate(true);
+        return vo;
+    }
+
+    private DualInflowControlManager.TargetMetrics makeMetrics(long allowed, long rejPs, long rejTh) {
+        DualInflowControlManager.TargetMetrics m = new DualInflowControlManager.TargetMetrics();
+        m.allowed.set(allowed);
+        m.rejectedPerSecond.set(rejPs);
+        m.rejectedThreshold.set(rejTh);
+        return m;
+    }
+
+    // =========================================================================
+    // DualManager null (비활성 환경)
+    // =========================================================================
+
+    @Test
+    void getAdapterMetric_managerIsNull_returnsNull() {
+        assertNull(serviceWith(null).getAdapterMetric("A1"));
+    }
+
+    @Test
+    void getAllAdapterMetrics_managerIsNull_returnsEmptyList() {
+        assertTrue(serviceWith(null).getAllAdapterMetrics().isEmpty());
+    }
+
+    @Test
+    void resetAdapterMetric_managerIsNull_returnsFalse() {
+        assertFalse(serviceWith(null).resetAdapterMetric("A1"));
+    }
+
+    @Test
+    void resetAllAdapterMetrics_managerIsNull_noException() {
+        assertDoesNotThrow(() -> serviceWith(null).resetAllAdapterMetrics());
+    }
+
+    @Test
+    void getInterfaceMetric_managerIsNull_returnsNull() {
+        assertNull(serviceWith(null).getInterfaceMetric("IF1"));
+    }
+
+    // =========================================================================
+    // 어댑터 — 단일 조회
+    // =========================================================================
+
+    @Test
+    void getAdapterMetric_notRegistered_returnsNull() {
+        DualInflowControlManager manager = mock(DualInflowControlManager.class);
+        when(manager.getAdapterInflowThreashold("A1")).thenReturn(null);
+
+        assertNull(serviceWith(manager).getAdapterMetric("A1"));
+    }
+
+    @Test
+    void getAdapterMetric_found_mapsFields() {
+        DualInflowControlManager manager = mock(DualInflowControlManager.class);
+        when(manager.getAdapterInflowThreashold("A1")).thenReturn(makeVO("A1"));
+        when(manager.getAdapterMetrics("A1")).thenReturn(makeMetrics(900, 60, 40));
+
+        TargetMetricDTO dto = serviceWith(manager).getAdapterMetric("A1");
+
+        assertNotNull(dto);
+        assertEquals("A1",      dto.getTargetId());
+        assertEquals("ADAPTER", dto.getTargetType());
+        assertTrue(dto.isActivate());
+        assertEquals(900, dto.getAllowed());
+        assertEquals(60,  dto.getRejectedPerSecond());
+        assertEquals(40,  dto.getRejectedThreshold());
+        assertEquals(1000, dto.getTotalRequests());
+    }
+
+    @Test
+    void getAdapterMetric_noMetricsYet_returnsZeroCounters() {
+        DualInflowControlManager manager = mock(DualInflowControlManager.class);
+        when(manager.getAdapterInflowThreashold("A1")).thenReturn(makeVO("A1"));
+        when(manager.getAdapterMetrics("A1")).thenReturn(null);
+
+        TargetMetricDTO dto = serviceWith(manager).getAdapterMetric("A1");
+
+        assertNotNull(dto);
+        assertEquals(0, dto.getAllowed());
+        assertEquals(0, dto.getTotalRequests());
+        assertEquals(0.0, dto.getRejectRatio(), 0.001);
+    }
+
+    @Test
+    void getAdapterMetric_rejectRatioCalculation() {
+        DualInflowControlManager manager = mock(DualInflowControlManager.class);
+        when(manager.getAdapterInflowThreashold("A1")).thenReturn(makeVO("A1"));
+        // allowed=90, rejPs=5, rejTh=5 → reject=10/100 = 10.00%
+        when(manager.getAdapterMetrics("A1")).thenReturn(makeMetrics(90, 5, 5));
+
+        TargetMetricDTO dto = serviceWith(manager).getAdapterMetric("A1");
+
+        assertEquals(10.0, dto.getRejectRatio(), 0.01);
+    }
+
+    @Test
+    void getAdapterMetric_zeroTotal_rejectRatioIsZero() {
+        DualInflowControlManager manager = mock(DualInflowControlManager.class);
+        when(manager.getAdapterInflowThreashold("A1")).thenReturn(makeVO("A1"));
+        when(manager.getAdapterMetrics("A1")).thenReturn(makeMetrics(0, 0, 0));
+
+        TargetMetricDTO dto = serviceWith(manager).getAdapterMetric("A1");
+
+        assertEquals(0.0, dto.getRejectRatio(), 0.0001);
+    }
+
+    // =========================================================================
+    // 어댑터 — 전체 조회
+    // =========================================================================
+
+    @Test
+    void getAllAdapterMetrics_twoEntries_returnsBoth() {
+        DualInflowControlManager manager = mock(DualInflowControlManager.class);
+        when(manager.getAdapterAllKeys()).thenReturn(new String[]{"A1", "A2"});
+        when(manager.getAdapterInflowThreashold("A1")).thenReturn(makeVO("A1"));
+        when(manager.getAdapterInflowThreashold("A2")).thenReturn(makeVO("A2"));
+        when(manager.getAdapterMetrics("A1")).thenReturn(makeMetrics(10, 0, 0));
+        when(manager.getAdapterMetrics("A2")).thenReturn(makeMetrics(20, 5, 0));
+
+        List<TargetMetricDTO> result = serviceWith(manager).getAllAdapterMetrics();
+
+        assertEquals(2, result.size());
+        assertEquals("A1", result.get(0).getTargetId());
+        assertEquals("A2", result.get(1).getTargetId());
+    }
+
+    @Test
+    void getAllAdapterMetrics_noKeys_returnsEmptyList() {
+        DualInflowControlManager manager = mock(DualInflowControlManager.class);
+        when(manager.getAdapterAllKeys()).thenReturn(new String[]{});
+
+        assertTrue(serviceWith(manager).getAllAdapterMetrics().isEmpty());
+    }
+
+    @Test
+    void getAllAdapterMetrics_notRegisteredSkipped() {
+        DualInflowControlManager manager = mock(DualInflowControlManager.class);
+        when(manager.getAdapterAllKeys()).thenReturn(new String[]{"A1", "GHOST"});
+        when(manager.getAdapterInflowThreashold("A1")).thenReturn(makeVO("A1"));
+        when(manager.getAdapterInflowThreashold("GHOST")).thenReturn(null);
+        when(manager.getAdapterMetrics("A1")).thenReturn(null);
+
+        List<TargetMetricDTO> result = serviceWith(manager).getAllAdapterMetrics();
+
+        assertEquals(1, result.size());
+        assertEquals("A1", result.get(0).getTargetId());
+    }
+
+    // =========================================================================
+    // 어댑터 — reset
+    // =========================================================================
+
+    @Test
+    void resetAdapterMetric_notRegistered_returnsFalse() {
+        DualInflowControlManager manager = mock(DualInflowControlManager.class);
+        when(manager.getAdapterInflowThreashold("A1")).thenReturn(null);
+
+        assertFalse(serviceWith(manager).resetAdapterMetric("A1"));
+        verify(manager, never()).resetAdapterMetrics(any());
+    }
+
+    @Test
+    void resetAdapterMetric_success_returnsTrueAndCallsManager() {
+        DualInflowControlManager manager = mock(DualInflowControlManager.class);
+        when(manager.getAdapterInflowThreashold("A1")).thenReturn(makeVO("A1"));
+
+        assertTrue(serviceWith(manager).resetAdapterMetric("A1"));
+        verify(manager).resetAdapterMetrics("A1");
+    }
+
+    @Test
+    void resetAllAdapterMetrics_callsManager() {
+        DualInflowControlManager manager = mock(DualInflowControlManager.class);
+
+        serviceWith(manager).resetAllAdapterMetrics();
+
+        verify(manager).resetAllAdapterMetrics();
+    }
+
+    // =========================================================================
+    // 인터페이스 — 단일 조회
+    // =========================================================================
+
+    @Test
+    void getInterfaceMetric_found_mapsFields() {
+        DualInflowControlManager manager = mock(DualInflowControlManager.class);
+        when(manager.getInterfaceInflowThreashold("IF1")).thenReturn(makeVO("IF1"));
+        when(manager.getInterfaceMetrics("IF1")).thenReturn(makeMetrics(50, 10, 5));
+
+        TargetMetricDTO dto = serviceWith(manager).getInterfaceMetric("IF1");
+
+        assertNotNull(dto);
+        assertEquals("IF1",       dto.getTargetId());
+        assertEquals("INTERFACE", dto.getTargetType());
+        assertEquals(50,  dto.getAllowed());
+        assertEquals(65,  dto.getTotalRequests());
+    }
+
+    @Test
+    void getInterfaceMetric_notRegistered_returnsNull() {
+        DualInflowControlManager manager = mock(DualInflowControlManager.class);
+        when(manager.getInterfaceInflowThreashold("IF1")).thenReturn(null);
+
+        assertNull(serviceWith(manager).getInterfaceMetric("IF1"));
+    }
+
+    @Test
+    void resetInterfaceMetric_success_returnsTrueAndCallsManager() {
+        DualInflowControlManager manager = mock(DualInflowControlManager.class);
+        when(manager.getInterfaceInflowThreashold("IF1")).thenReturn(makeVO("IF1"));
+
+        assertTrue(serviceWith(manager).resetInterfaceMetric("IF1"));
+        verify(manager).resetInterfaceMetrics("IF1");
+    }
+
+    @Test
+    void resetInterfaceMetric_notRegistered_returnsFalse() {
+        DualInflowControlManager manager = mock(DualInflowControlManager.class);
+        when(manager.getInterfaceInflowThreashold("IF1")).thenReturn(null);
+
+        assertFalse(serviceWith(manager).resetInterfaceMetric("IF1"));
+    }
+
+    @Test
+    void resetAllInterfaceMetrics_callsManager() {
+        DualInflowControlManager manager = mock(DualInflowControlManager.class);
+        serviceWith(manager).resetAllInterfaceMetrics();
+        verify(manager).resetAllInterfaceMetrics();
+    }
+}