From 9d3482b43b32f66244c18028b7c5a062096c78ca Mon Sep 17 00:00:00 2001
From: HanYoonSoo <hdbstn3055@gmail.com>
Date: Mon, 29 Jun 2026 11:00:25 +0900
Subject: [PATCH 1/2] =?UTF-8?q?refactor:=20=EC=9D=B8=ED=94=8C=EB=A3=A8?=
 =?UTF-8?q?=EC=96=B8=EC=84=9C=20=EC=9D=B8=EC=82=AC=EC=9D=B4=ED=8A=B8=20?=
 =?UTF-8?q?=EC=A1=B0=ED=9A=8C=20=EB=B2=94=EC=9C=84=20=EB=B6=84=EB=A6=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../insight/InfluencerInsightCalculator.java  |  53 ++++---
 .../InfluencerInsightQueryService.java        |  25 +++-
 .../video/repository/VideoRepository.java     |  23 +++
 .../VideoFormatStatsProjection.java           |   9 ++
 .../InfluencerInsightCalculatorTest.java      |  56 ++++++++
 .../InfluencerInsightQueryServiceTest.java    | 133 ++++++++++++++++++
 6 files changed, 274 insertions(+), 25 deletions(-)
 create mode 100644 src/main/java/com/example/inflace/domain/video/repository/projection/VideoFormatStatsProjection.java
 create mode 100644 src/test/java/com/example/inflace/domain/channel/service/insight/InfluencerInsightCalculatorTest.java
 create mode 100644 src/test/java/com/example/inflace/domain/channel/service/insight/InfluencerInsightQueryServiceTest.java

diff --git a/src/main/java/com/example/inflace/domain/channel/service/insight/InfluencerInsightCalculator.java b/src/main/java/com/example/inflace/domain/channel/service/insight/InfluencerInsightCalculator.java
index 84e4d6f0..2c3d1fb8 100644
--- a/src/main/java/com/example/inflace/domain/channel/service/insight/InfluencerInsightCalculator.java
+++ b/src/main/java/com/example/inflace/domain/channel/service/insight/InfluencerInsightCalculator.java
@@ -5,6 +5,7 @@
 import com.example.inflace.domain.channel.dto.response.GetInfluencerInsightResponse;
 import com.example.inflace.domain.video.domain.Video;
 import com.example.inflace.domain.video.domain.VideoStats;
+import com.example.inflace.domain.video.repository.projection.VideoFormatStatsProjection;
 import com.example.inflace.global.util.AnalyticsCalculator;
 import java.time.LocalDateTime;
 import java.util.ArrayList;
@@ -25,7 +26,6 @@ public class InfluencerInsightCalculator {
     private static final int CONTENT_WINDOW_SIZE = 50;
     private static final int GROWTH_WINDOW_SIZE = 25;
     private static final int FREQUENCY_INTERVAL_WINDOW_SIZE = 5;
-    private static final int RECENT_WINDOW_DAYS = 30;
     private static final int MIN_ADVERTISEMENT_VIDEO_COUNT = 3;
 
     public InfluencerInsightCalculator(InfluencerInsightScoreCalculator scoreCalculator) {
@@ -37,7 +37,8 @@ public GetInfluencerInsightResponse calculate(
             ChannelStats channelStats,
             List<String> categories,
             List<Video> videos,
-            Map<Long, VideoStats> videoStatsMap
+            Map<Long, VideoStats> videoStatsMap,
+            List<VideoFormatStatsProjection> recentFormatProjections
     ) {
         List<VideoMetric> metrics = buildVideoMetrics(videos, videoStatsMap);
         List<Video> latestVideos = getLatestVideos(videos);
@@ -47,7 +48,7 @@ public GetInfluencerInsightResponse calculate(
         GetInfluencerInsightResponse.Content content = buildContentMetrics(latestMetrics);
         GetInfluencerInsightResponse.Activity activity = buildActivityMetrics(latestVideos);
         GetInfluencerInsightResponse.Advertisement advertisement = buildAdvertisementMetrics(latestMetrics, channelStats);
-        GetInfluencerInsightResponse.FormatAnalysis formatAnalysis = buildFormatAnalysis(metrics);
+        GetInfluencerInsightResponse.FormatAnalysis formatAnalysis = buildFormatAnalysis(recentFormatProjections);
 
         return new GetInfluencerInsightResponse(
                 channel.getId(),
@@ -203,29 +204,27 @@ private GetInfluencerInsightResponse.Activity buildActivityMetrics(List<Video> v
         );
     }
 
-    private GetInfluencerInsightResponse.FormatAnalysis buildFormatAnalysis(List<VideoMetric> metrics) {
-        LocalDateTime recent30d = LocalDateTime.now().minusDays(RECENT_WINDOW_DAYS);
-
-        List<VideoMetric> recentLongForm = metrics.stream()
-                .filter(metric -> metric.publishedAt() != null && !metric.publishedAt().isBefore(recent30d))
-                .filter(metric -> !metric.isShort())
+    private GetInfluencerInsightResponse.FormatAnalysis buildFormatAnalysis(
+            List<VideoFormatStatsProjection> projections
+    ) {
+        List<VideoFormatStatsProjection> recentLongForm = projections.stream()
+                .filter(projection -> !projection.isShort())
                 .toList();
 
-        List<VideoMetric> recentShortForm = metrics.stream()
-                .filter(metric -> metric.publishedAt() != null && !metric.publishedAt().isBefore(recent30d))
-                .filter(VideoMetric::isShort)
+        List<VideoFormatStatsProjection> recentShortForm = projections.stream()
+                .filter(VideoFormatStatsProjection::isShort)
                 .toList();
 
         return new GetInfluencerInsightResponse.FormatAnalysis(
                 new GetInfluencerInsightResponse.FormatMetric(
                         recentLongForm.size(),
-                        calculateRound(averageViewCount(recentLongForm)),
-                        calculateRound(averageEngagementRate(recentLongForm))
+                        calculateRound(averageFormatViewCount(recentLongForm)),
+                        calculateRound(averageFormatEngagementRate(recentLongForm))
                 ),
                 new GetInfluencerInsightResponse.FormatMetric(
                         recentShortForm.size(),
-                        calculateRound(averageViewCount(recentShortForm)),
-                        calculateRound(averageEngagementRate(recentShortForm))
+                        calculateRound(averageFormatViewCount(recentShortForm)),
+                        calculateRound(averageFormatEngagementRate(recentShortForm))
                 )
         );
     }
@@ -305,12 +304,26 @@ private double averageViewCount(List<VideoMetric> metrics) {
                 .orElse(0.0);
     }
 
-    private double averageEngagementRate(List<VideoMetric> metrics) {
-        if (metrics.isEmpty()) {
+    private double averageFormatViewCount(List<VideoFormatStatsProjection> projections) {
+        if (projections.isEmpty()) {
             return 0.0;
         }
-        return metrics.stream()
-                .mapToDouble(VideoMetric::engagementRate)
+        return projections.stream()
+                .mapToLong(VideoFormatStatsProjection::viewCount)
+                .average()
+                .orElse(0.0);
+    }
+
+    private double averageFormatEngagementRate(List<VideoFormatStatsProjection> projections) {
+        if (projections.isEmpty()) {
+            return 0.0;
+        }
+        return projections.stream()
+                .mapToDouble(projection -> AnalyticsCalculator.engagementRate(
+                        projection.likeCount(),
+                        projection.commentCount(),
+                        projection.viewCount()
+                ))
                 .average()
                 .orElse(0.0);
     }
diff --git a/src/main/java/com/example/inflace/domain/channel/service/insight/InfluencerInsightQueryService.java b/src/main/java/com/example/inflace/domain/channel/service/insight/InfluencerInsightQueryService.java
index bf786308..cfe725c3 100644
--- a/src/main/java/com/example/inflace/domain/channel/service/insight/InfluencerInsightQueryService.java
+++ b/src/main/java/com/example/inflace/domain/channel/service/insight/InfluencerInsightQueryService.java
@@ -10,14 +10,18 @@
 import com.example.inflace.domain.channel.repository.ChannelStatsRepository;
 import com.example.inflace.domain.video.domain.Video;
 import com.example.inflace.domain.video.repository.VideoRepository;
+import com.example.inflace.domain.video.repository.projection.VideoFormatStatsProjection;
 import com.example.inflace.domain.video.service.VideoService;
 import com.example.inflace.global.annotation.ReadOnlyTransactional;
 import com.example.inflace.global.exception.ApiException;
 import com.example.inflace.global.exception.ErrorDefine;
+import java.time.LocalDateTime;
+import java.time.ZoneOffset;
 import java.util.List;
 import java.util.Objects;
 
 import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.PageRequest;
 import org.springframework.stereotype.Service;
 import org.springframework.util.StringUtils;
 
@@ -26,7 +30,9 @@
 public class InfluencerInsightQueryService {
 
     private static final int MIN_VIDEO_COUNT_FOR_INSIGHT = 10;
+    private static final int LATEST_VIDEO_COUNT_FOR_INSIGHT = 50;
     private static final int MAX_RECENT_VIDEO_DESCRIPTION_COUNT = 10;
+    private static final int RECENT_WINDOW_DAYS = 30;
 
     private final ChannelRepository channelRepository;
     private final ChannelStatsRepository channelStatsRepository;
@@ -40,10 +46,18 @@ public InfluencerInsightQueryResult getInsightQueryResult(Long channelId) {
         Channel channel = channelRepository.findById(channelId)
                 .orElseThrow(() -> new ApiException(ErrorDefine.CHANNEL_NOT_FOUND));
 
-        List<Video> videos = videoRepository.findByChannelIdOrderByPublishedAtDesc(channelId);
-        if (videos.size() < MIN_VIDEO_COUNT_FOR_INSIGHT) {
+        if (videoRepository.countByChannelId(channelId) < MIN_VIDEO_COUNT_FOR_INSIGHT) {
             throw new ApiException(ErrorDefine.CHANNEL_INSIGHT_REQUIRES_MIN_VIDEO_COUNT);
         }
+        List<Video> latestVideos = videoRepository.findByChannelIdOrderByPublishedAtDesc(
+                channelId,
+                PageRequest.of(0, LATEST_VIDEO_COUNT_FOR_INSIGHT)
+        );
+        List<VideoFormatStatsProjection> recentFormatProjections = videoRepository
+                .findFormatStatsRowsByChannelIdAndPublishedAtGreaterThanEqual(
+                        channelId,
+                        LocalDateTime.now(ZoneOffset.UTC).minusDays(RECENT_WINDOW_DAYS)
+                );
         List<String> categories = channelCategoryRepository.findAllByChannel_Id(channelId).stream()
                 .map(ChannelCategory::getCategory)
                 .filter(Objects::nonNull)
@@ -56,13 +70,14 @@ public InfluencerInsightQueryResult getInsightQueryResult(Long channelId) {
                 channel,
                 channelStats,
                 categories,
-                videos,
-                videoService.getVideoStatsMap(videos)
+                latestVideos,
+                videoService.getVideoStatsMap(latestVideos),
+                recentFormatProjections
         );
 
         return new InfluencerInsightQueryResult(
                 channel.getDescription(),
-                getRecentVideoDescriptions(videos),
+                getRecentVideoDescriptions(latestVideos),
                 insight
         );
     }
diff --git a/src/main/java/com/example/inflace/domain/video/repository/VideoRepository.java b/src/main/java/com/example/inflace/domain/video/repository/VideoRepository.java
index 9a795d45..94664353 100644
--- a/src/main/java/com/example/inflace/domain/video/repository/VideoRepository.java
+++ b/src/main/java/com/example/inflace/domain/video/repository/VideoRepository.java
@@ -1,6 +1,7 @@
 package com.example.inflace.domain.video.repository;
 
 import com.example.inflace.domain.video.domain.Video;
+import com.example.inflace.domain.video.repository.projection.VideoFormatStatsProjection;
 import java.time.LocalDateTime;
 import java.util.List;
 import java.util.Optional;
@@ -52,7 +53,29 @@ order by coalesce(vs.risingScore, 0) desc, coalesce(va.ctr, 0) desc, v.id desc
 
     Long countByChannelIdAndPublishedAtGreaterThanEqual(Long channelId, LocalDateTime publishedAt);
 
+    long countByChannelId(Long channelId);
+
     List<Video> findByChannelId(Long channelId);
 
     List<Video> findByChannelIdOrderByPublishedAtDesc(Long channelId);
+
+    List<Video> findByChannelIdOrderByPublishedAtDesc(Long channelId, Pageable pageable);
+
+    @Query("""
+            select new com.example.inflace.domain.video.repository.projection.VideoFormatStatsProjection(
+                v.isShort,
+                vs.viewCount,
+                vs.likeCount,
+                vs.commentCount
+            )
+            from Video v
+            join VideoStats vs on vs.video = v
+            where v.channel.id = :channelId
+              and v.publishedAt >= :publishedAt
+            """)
+    List<VideoFormatStatsProjection> findFormatStatsRowsByChannelIdAndPublishedAtGreaterThanEqual(
+            @Param("channelId") Long channelId,
+            @Param("publishedAt") LocalDateTime publishedAt
+    );
+
 }
diff --git a/src/main/java/com/example/inflace/domain/video/repository/projection/VideoFormatStatsProjection.java b/src/main/java/com/example/inflace/domain/video/repository/projection/VideoFormatStatsProjection.java
new file mode 100644
index 00000000..c8a51693
--- /dev/null
+++ b/src/main/java/com/example/inflace/domain/video/repository/projection/VideoFormatStatsProjection.java
@@ -0,0 +1,9 @@
+package com.example.inflace.domain.video.repository.projection;
+
+public record VideoFormatStatsProjection(
+        boolean isShort,
+        long viewCount,
+        long likeCount,
+        long commentCount
+) {
+}
diff --git a/src/test/java/com/example/inflace/domain/channel/service/insight/InfluencerInsightCalculatorTest.java b/src/test/java/com/example/inflace/domain/channel/service/insight/InfluencerInsightCalculatorTest.java
new file mode 100644
index 00000000..ccc7b193
--- /dev/null
+++ b/src/test/java/com/example/inflace/domain/channel/service/insight/InfluencerInsightCalculatorTest.java
@@ -0,0 +1,56 @@
+package com.example.inflace.domain.channel.service.insight;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.example.inflace.domain.channel.domain.Channel;
+import com.example.inflace.domain.channel.dto.response.GetInfluencerInsightResponse;
+import com.example.inflace.domain.video.domain.Video;
+import com.example.inflace.domain.video.domain.VideoStats;
+import com.example.inflace.domain.video.repository.projection.VideoFormatStatsProjection;
+import java.util.List;
+import java.util.Map;
+import org.junit.jupiter.api.Test;
+import org.springframework.test.util.ReflectionTestUtils;
+
+class InfluencerInsightCalculatorTest {
+
+    @Test
+    void formatAnalysisUsesRecentThirtyDayProjectionRows() {
+        InfluencerInsightCalculator calculator = new InfluencerInsightCalculator(new InfluencerInsightScoreCalculator());
+        Video video = video();
+        VideoStats stats = VideoStats.builder()
+                .video(video)
+                .viewCount(100L)
+                .likeCount(10L)
+                .commentCount(5L)
+                .build();
+
+        GetInfluencerInsightResponse response = calculator.calculate(
+                Channel.builder().name("test-channel").build(),
+                null,
+                List.of(),
+                List.of(video),
+                Map.of(video.getId(), stats),
+                List.of(
+                        new VideoFormatStatsProjection(false, 100L, 10L, 5L),
+                        new VideoFormatStatsProjection(true, 50L, 5L, 5L)
+                )
+        );
+
+        assertThat(response.formatAnalysis().longForm().count())
+                .as("expected long-form count from recent 30-day projection rows")
+                .isOne();
+        assertThat(response.formatAnalysis().shortForm().count())
+                .as("expected short-form count from recent 30-day projection rows")
+                .isOne();
+    }
+
+    private Video video() {
+        Video video = Video.builder()
+                .title("test-video")
+                .isShort(false)
+                .build();
+        ReflectionTestUtils.setField(video, "id", 1L);
+        return video;
+    }
+}
diff --git a/src/test/java/com/example/inflace/domain/channel/service/insight/InfluencerInsightQueryServiceTest.java b/src/test/java/com/example/inflace/domain/channel/service/insight/InfluencerInsightQueryServiceTest.java
new file mode 100644
index 00000000..4567085e
--- /dev/null
+++ b/src/test/java/com/example/inflace/domain/channel/service/insight/InfluencerInsightQueryServiceTest.java
@@ -0,0 +1,133 @@
+package com.example.inflace.domain.channel.service.insight;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.verify;
+
+import com.example.inflace.domain.channel.domain.Channel;
+import com.example.inflace.domain.channel.dto.response.GetInfluencerInsightResponse;
+import com.example.inflace.domain.channel.repository.ChannelCategoryRepository;
+import com.example.inflace.domain.channel.repository.ChannelRepository;
+import com.example.inflace.domain.channel.repository.ChannelStatsRepository;
+import com.example.inflace.domain.video.domain.Video;
+import com.example.inflace.domain.video.repository.VideoRepository;
+import com.example.inflace.domain.video.service.VideoService;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.ZoneOffset;
+import java.util.List;
+import java.util.Optional;
+import java.util.TimeZone;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.data.domain.Pageable;
+import org.springframework.test.util.ReflectionTestUtils;
+
+@ExtendWith(MockitoExtension.class)
+class InfluencerInsightQueryServiceTest {
+
+    private final TimeZone originalTimeZone = TimeZone.getDefault();
+
+    @Mock
+    ChannelRepository channelRepository;
+
+    @Mock
+    ChannelStatsRepository channelStatsRepository;
+
+    @Mock
+    ChannelCategoryRepository channelCategoryRepository;
+
+    @Mock
+    VideoRepository videoRepository;
+
+    @Mock
+    VideoService videoService;
+
+    @Mock
+    InfluencerInsightCalculator influencerInsightCalculator;
+
+    @InjectMocks
+    InfluencerInsightQueryService queryService;
+
+    @AfterEach
+    void restoreTimeZone() {
+        TimeZone.setDefault(originalTimeZone);
+    }
+
+    @Test
+    void getInsightQueryResultUsesBoundedQueriesAndUtcRecentWindow() {
+        TimeZone.setDefault(TimeZone.getTimeZone(ZoneId.of("Asia/Seoul")));
+        Channel channel = Channel.builder()
+                .name("test-channel")
+                .build();
+        ReflectionTestUtils.setField(channel, "id", 1L);
+        given(channelRepository.findById(1L)).willReturn(Optional.of(channel));
+        given(videoRepository.countByChannelId(1L)).willReturn(10L);
+        List<Video> latestVideos = List.of(
+                Video.builder()
+                        .description("recent-description")
+                        .build()
+        );
+        given(videoRepository.findByChannelIdOrderByPublishedAtDesc(eq(1L), any(Pageable.class)))
+                .willReturn(latestVideos);
+        given(videoRepository.findFormatStatsRowsByChannelIdAndPublishedAtGreaterThanEqual(eq(1L), any()))
+                .willReturn(List.of());
+        given(channelCategoryRepository.findAllByChannel_Id(1L)).willReturn(List.of());
+        given(channelStatsRepository.findByChannel_Id(1L)).willReturn(Optional.empty());
+        given(videoService.getVideoStatsMap(latestVideos)).willReturn(java.util.Map.of());
+        given(influencerInsightCalculator.calculate(any(), any(), any(), any(), any(), any()))
+                .willReturn(insightResponse());
+
+        LocalDateTime beforeUtcCutoff = LocalDateTime.now(ZoneOffset.UTC).minusDays(30);
+
+        InfluencerInsightQueryResult result = queryService.getInsightQueryResult(1L);
+
+        ArgumentCaptor<Pageable> latestPageableCaptor = ArgumentCaptor.forClass(Pageable.class);
+        verify(videoRepository).findByChannelIdOrderByPublishedAtDesc(eq(1L), latestPageableCaptor.capture());
+        assertThat(latestPageableCaptor.getValue().getPageSize())
+                .as("expected latest video query to load at most 50 videos")
+                .isEqualTo(50);
+
+        ArgumentCaptor<LocalDateTime> cutoffCaptor = ArgumentCaptor.forClass(LocalDateTime.class);
+        verify(videoRepository).findFormatStatsRowsByChannelIdAndPublishedAtGreaterThanEqual(
+                eq(1L),
+                cutoffCaptor.capture()
+        );
+        assertThat(cutoffCaptor.getValue())
+                .as("expected recent format cutoff to be based on UTC, not default JVM timezone")
+                .isBetween(beforeUtcCutoff, LocalDateTime.now(ZoneOffset.UTC).minusDays(30));
+
+        assertThat(result.recentVideoDescriptions())
+                .as("expected recent descriptions to be reused from latest 50 videos")
+                .containsExactly("recent-description");
+    }
+
+    private GetInfluencerInsightResponse insightResponse() {
+        return new GetInfluencerInsightResponse(
+                1L,
+                "test-channel",
+                null,
+                null,
+                null,
+                null,
+                0L,
+                false,
+                List.of(),
+                null,
+                null,
+                null,
+                null,
+                new GetInfluencerInsightResponse.FormatAnalysis(
+                        new GetInfluencerInsightResponse.FormatMetric(0, 0.0, 0.0),
+                        new GetInfluencerInsightResponse.FormatMetric(0, 0.0, 0.0)
+                )
+        );
+    }
+}

From 26568b8a5748217168e60d2962e8ed1209f16bc9 Mon Sep 17 00:00:00 2001
From: HanYoonSoo <hdbstn3055@gmail.com>
Date: Mon, 29 Jun 2026 11:03:47 +0900
Subject: [PATCH 2/2] =?UTF-8?q?fix:=20=EC=9D=B8=ED=94=8C=EB=A3=A8=EC=96=B8?=
 =?UTF-8?q?=EC=84=9C=20=EC=9D=B8=EC=82=AC=EC=9D=B4=ED=8A=B8=20=EB=B9=84?=
 =?UTF-8?q?=EC=9C=A8=20=EB=B6=84=EB=AA=A8=EB=A5=BC=20=EC=8B=A4=EC=A0=9C=20?=
 =?UTF-8?q?=EC=98=81=EC=83=81=20=EC=88=98=EB=A1=9C=20=EA=B3=84=EC=82=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../insight/InfluencerInsightCalculator.java  |  2 +-
 .../InfluencerInsightCalculatorTest.java      | 51 +++++++++++++++++++
 2 files changed, 52 insertions(+), 1 deletion(-)

diff --git a/src/main/java/com/example/inflace/domain/channel/service/insight/InfluencerInsightCalculator.java b/src/main/java/com/example/inflace/domain/channel/service/insight/InfluencerInsightCalculator.java
index 2c3d1fb8..03d310dc 100644
--- a/src/main/java/com/example/inflace/domain/channel/service/insight/InfluencerInsightCalculator.java
+++ b/src/main/java/com/example/inflace/domain/channel/service/insight/InfluencerInsightCalculator.java
@@ -291,7 +291,7 @@ private double calculateFixedWindowPercentOf(
                 .filter(predicate)
                 .count();
 
-        return matched * 100.0 / CONTENT_WINDOW_SIZE;
+        return matched * 100.0 / metrics.size();
     }
 
     private double averageViewCount(List<VideoMetric> metrics) {
diff --git a/src/test/java/com/example/inflace/domain/channel/service/insight/InfluencerInsightCalculatorTest.java b/src/test/java/com/example/inflace/domain/channel/service/insight/InfluencerInsightCalculatorTest.java
index ccc7b193..bce723f3 100644
--- a/src/test/java/com/example/inflace/domain/channel/service/insight/InfluencerInsightCalculatorTest.java
+++ b/src/test/java/com/example/inflace/domain/channel/service/insight/InfluencerInsightCalculatorTest.java
@@ -7,6 +7,9 @@
 import com.example.inflace.domain.video.domain.Video;
 import com.example.inflace.domain.video.domain.VideoStats;
 import com.example.inflace.domain.video.repository.projection.VideoFormatStatsProjection;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import org.junit.jupiter.api.Test;
@@ -14,6 +17,44 @@
 
 class InfluencerInsightCalculatorTest {
 
+    @Test
+    void viralRatesUseActualMetricCountWhenLatestVideosAreLessThanFifty() {
+        InfluencerInsightCalculator calculator = new InfluencerInsightCalculator(new InfluencerInsightScoreCalculator());
+        Channel channel = Channel.builder()
+                .name("test-channel")
+                .build();
+        List<Long> viewCounts = List.of(1000L, 500L, 400L, 10L, 10L, 10L, 10L, 10L, 10L, 10L);
+        List<Video> videos = new ArrayList<>();
+        Map<Long, VideoStats> statsMap = new HashMap<>();
+
+        for (int i = 0; i < viewCounts.size(); i++) {
+            Video video = video((long) i + 1, LocalDateTime.now().minusDays(i));
+            videos.add(video);
+            statsMap.put(video.getId(), VideoStats.builder()
+                    .video(video)
+                    .viewCount(viewCounts.get(i))
+                    .likeCount(0L)
+                    .commentCount(0L)
+                    .build());
+        }
+
+        GetInfluencerInsightResponse response = calculator.calculate(
+                channel,
+                null,
+                List.of(),
+                videos,
+                statsMap,
+                List.of()
+        );
+
+        assertThat(response.content().viral2xRate())
+                .as("expected viral2xRate to use actual 10-video denominator, not fixed 50 denominator")
+                .isEqualTo(30.0);
+        assertThat(response.content().viral5xRate())
+                .as("expected viral5xRate to use actual 10-video denominator, not fixed 50 denominator")
+                .isEqualTo(10.0);
+    }
+
     @Test
     void formatAnalysisUsesRecentThirtyDayProjectionRows() {
         InfluencerInsightCalculator calculator = new InfluencerInsightCalculator(new InfluencerInsightScoreCalculator());
@@ -53,4 +94,14 @@ private Video video() {
         ReflectionTestUtils.setField(video, "id", 1L);
         return video;
     }
+
+    private Video video(Long id, LocalDateTime publishedAt) {
+        Video video = Video.builder()
+                .title("test-video-" + id)
+                .publishedAt(publishedAt)
+                .isShort(false)
+                .build();
+        ReflectionTestUtils.setField(video, "id", id);
+        return video;
+    }
 }