test: expand rspec coverage across all modules

Author: Bulletdev

app/controllers/api/v1/monitoring_controller.rb

@@ -28,8 +28,8 @@ class MonitoringController < BaseController
       # Names must match self.class.name inside each job (after Zeitwerk namespace
       # resolution) because record_job_heartbeat uses "prostaff:job_heartbeat:#{name}".
       SCHEDULED_JOBS = [
-        { name: 'Analytics::RefreshMetadataViewsJob',      interval_hours: 2,  alert_after_hours: 3  },
-        { name: 'Authentication::CleanupExpiredTokensJob',  interval_hours: 24, alert_after_hours: 25 }
+        { name: 'Analytics::RefreshMetadataViewsJob', interval_hours: 2, alert_after_hours: 3 },
+        { name: 'Authentication::CleanupExpiredTokensJob', interval_hours: 24, alert_after_hours: 25 }
       ].freeze
 
       # GET /api/v1/monitoring/sidekiq

app/modules/analytics/controllers/competitive_player_controller.rb

@@ -23,7 +23,7 @@ module Controllers
     class CompetitivePlayerController < Api::V1::BaseController
       def player_stats
         summoner_name = params[:summoner_name].to_s.strip
-        return render_error('summoner_name is required', :bad_request) if summoner_name.blank?
+        return render_error(message: 'summoner_name is required', status: :bad_request) if summoner_name.blank?
 
         matches = scoped_matches(summoner_name)
         return render_success(empty_response(summoner_name)) if matches.empty?

app/modules/competitive/jobs/historical_backfill_job.rb

@@ -49,7 +49,7 @@ def perform
 
       # Step 1: Trigger the backfill on the scraper (returns immediately).
       Rails.logger.info(
-        "[HistoricalBackfillJob] Triggering backfill on scraper: " \
+        '[HistoricalBackfillJob] Triggering backfill on scraper: ' \
         "league=#{league} min_year=#{min_year}"
       )
 
@@ -64,7 +64,7 @@ def perform
       rescue ProStaffScraperService::ScraperError => e
         Rails.logger.warn(
           "[HistoricalBackfillJob] Scraper trigger failed: #{e.message}. " \
-          "Proceeding to sync step (scraper may already be running)."
+          'Proceeding to sync step (scraper may already be running).'
         )
       end
 
@@ -98,7 +98,7 @@ def perform
           )
 
           # If nothing is pending/in-progress, the backfill is done.
-          break if remaining == 0
+          break if remaining.zero?
         rescue ProStaffScraperService::ScraperError => e
           Rails.logger.warn(
             "[HistoricalBackfillJob] Status poll failed: #{e.message}"
@@ -110,7 +110,7 @@ def perform
 
       # Step 3: Sync matches from ES into Rails DB for all organizations.
       Rails.logger.info(
-        "[HistoricalBackfillJob] Starting sync step: " \
+        '[HistoricalBackfillJob] Starting sync step: ' \
         "league=#{league} our_team=#{our_team} limit=#{sync_limit}"
       )
 
@@ -128,7 +128,7 @@ def perform
 
       record_job_heartbeat
 
-      Rails.logger.info("[HistoricalBackfillJob] Done.")
+      Rails.logger.info('[HistoricalBackfillJob] Done.')
     end
   end
 end

app/modules/competitive/jobs/sync_scraper_matches_job.rb

@@ -68,6 +68,8 @@ def perform(organization_id, league:, our_team: nil, limit: 100)
         "totals=#{totals.inspect}"
       )
 
+      AiIntelligence::RebuildChampionMatrixJob.perform_later if totals[:imported].positive?
+
       totals
     rescue ActiveRecord::RecordNotFound => e
       Rails.logger.error "[SyncScraperMatchesJob] Organization #{organization_id} not found: #{e.message}"

app/modules/competitive/services/draft_comparator_service.rb

@@ -145,37 +145,9 @@ def meta_analysis(role:, patch:)
   # @param patch [String] Patch version
   # @return [Array<Hash>] Suggested counters with winrate
   def suggest_counters(opponent_pick:, role:, patch:)
-    # Find matches where opponent_pick was played
-    matches = CompetitiveMatch.recent(30)
-    matches = matches.by_patch(patch) if patch.present?
-
-    counters = Hash.new { |h, k| h[k] = { wins: 0, total: 0 } }
-
-    matches.each do |match|
-      # Check if opponent picked this champion in this role
-      opponent_champion = match.opponent_picks.find do |p|
-        p['champion'] == opponent_pick && p['role']&.downcase == role.downcase
-      end
-
-      next unless opponent_champion
-
-      # Find what was picked against it in same role
-      our_champion = match.our_picks.find { |p| p['role']&.downcase == role.downcase }
-      next unless our_champion && our_champion['champion']
-
-      counter_name = our_champion['champion']
-      counters[counter_name][:total] += 1
-      counters[counter_name][:wins] += 1 if match.victory?
-    end
-
-    # Calculate winrates and sort
-    counters.map do |champion, stats|
-      {
-        champion: champion,
-        games: stats[:total],
-        winrate: ((stats[:wins].to_f / stats[:total]) * 100).round(2)
-      }
-    end.sort_by { |c| -c[:winrate] }.first(5)
+    matches = fetch_matches_for_patch(patch)
+    counters = build_counters_hash(matches, opponent_pick: opponent_pick, role: role)
+    format_counters(counters)
   end
 
   private
@@ -203,4 +175,43 @@ def extract_picks_and_bans(matches, role)
 
     [picks, bans]
   end
+
+  def fetch_matches_for_patch(patch)
+    matches = CompetitiveMatch.recent(30)
+    patch.present? ? matches.by_patch(patch) : matches
+  end
+
+  def build_counters_hash(matches, opponent_pick:, role:)
+    counters = Hash.new { |h, k| h[k] = { wins: 0, total: 0 } }
+    matches.each { |match| accumulate_counter(counters, match, opponent_pick: opponent_pick, role: role) }
+    counters
+  end
+
+  def accumulate_counter(counters, match, opponent_pick:, role:)
+    opponent_champion = find_opponent_pick(match, opponent_pick: opponent_pick, role: role)
+    return unless opponent_champion
+
+    our_champion = match.our_picks.find { |p| p['role']&.downcase == role.downcase }
+    return unless our_champion && our_champion['champion']
+
+    counter_name = our_champion['champion']
+    counters[counter_name][:total] += 1
+    counters[counter_name][:wins] += 1 if match.victory?
+  end
+
+  def find_opponent_pick(match, opponent_pick:, role:)
+    match.opponent_picks.find do |p|
+      p['champion'] == opponent_pick && p['role']&.downcase == role.downcase
+    end
+  end
+
+  def format_counters(counters)
+    counters.map do |champion, stats|
+      {
+        champion: champion,
+        games: stats[:total],
+        winrate: ((stats[:wins].to_f / stats[:total]) * 100).round(2)
+      }
+    end.sort_by { |c| -c[:winrate] }.first(5)
+  end
 end

app/modules/matches/controllers/export_controller.rb

@@ -13,6 +13,8 @@ module Controllers
     #   GET /api/v1/matches/:id/export          -> JSON
     #   GET /api/v1/matches/:id/export?format=csv -> CSV
     class ExportController < Api::V1::BaseController
+      skip_before_action :set_default_response_format
+
       EXPORT_FIELDS = %w[
         player_name champion role kills deaths assists
         cs neutral_minions_killed cs_at_10
@@ -44,7 +46,7 @@ def render_json_export(match, stats)
                          match_id: match.id,
                          riot_match_id: match.riot_match_id,
                          game_start: match.game_start,
-                         patch_version: match.patch_version,
+                         patch_version: match.game_version,
                          players: stats.map { |s| build_row_hash(s) }
                        })
       end

app/modules/messaging/controllers/messages_controller.rb

@@ -31,10 +31,10 @@ def index
 
         result = paginate(messages, per_page: 50)
 
-        render_success(
-          messages: serialize_messages(result[:data].reverse),
-          pagination: result[:pagination]
-        )
+        render_success({
+                         messages: serialize_messages(result[:data].reverse),
+                         pagination: result[:pagination]
+                       })
       rescue ActionController::ParameterMissing
         render_error(
           message: 'recipient_id is required',

app/modules/meta_intelligence/controllers/builds_controller.rb

@@ -99,7 +99,7 @@ def destroy
       # @param [String] patch   specific patch to aggregate (optional)
       # @return [JSON] { message: 'Aggregation enqueued' }
       def aggregate
-        Jobs::UpdateMetaStatsJob.perform_later(
+        MetaIntelligence::UpdateMetaStatsJob.perform_later(
           current_organization.id,
           scope: params[:scope] || 'org',
           patch: params[:patch]

app/modules/players/controllers/rosters_controller.rb

@@ -155,7 +155,7 @@ def set_player
       end
 
       def set_scouting_target
-        @scouting_target = organization_scoped(ScoutingTarget).find(params[:scouting_target_id])
+        @scouting_target = ScoutingTarget.find(params[:scouting_target_id])
       rescue ActiveRecord::RecordNotFound
         render_error(
           message: 'Scouting target not found',

app/modules/players/controllers/stats_export_controller.rb

@@ -13,6 +13,8 @@ module Controllers
     #   GET /api/v1/players/:id/stats/export
     #   GET /api/v1/players/:id/stats/export?format=csv&from=2026-01-01&to=2026-03-06
     class StatsExportController < Api::V1::BaseController
+      skip_before_action :set_default_response_format
+
       EXPORT_FIELDS = %w[
         match_date patch_version opponent champion role
         kills deaths assists kda_display cs cs_at_10 cs_per_min
@@ -27,7 +29,7 @@ class StatsExportController < Api::V1::BaseController
       ].freeze
 
       def show
-        player = organization_scoped(Player).find(params[:player_id])
+        player = organization_scoped(Player).find(params[:id])
         stats  = filtered_stats(player)
 
         respond_to do |format|
@@ -85,8 +87,8 @@ def build_row_array(stat)
 
       def export_field_value(stat, field)
         case field
-        when 'match_date'   then stat.match&.game_start&.strftime('%Y-%m-%d')
-        when 'patch_version' then stat.match&.patch_version
+        when 'match_date' then stat.match&.game_start&.strftime('%Y-%m-%d')
+        when 'patch_version' then stat.match&.game_version
         when 'opponent'     then stat.match&.opponent_name
         when 'result'       then stat.match&.victory? ? 'W' : 'L'
         when 'kda_display'  then stat.kda_display