如何统计非Rails Ruby项目中Rspec测试方法的使用情况？

Great question! When dealing with a large, aging UI test suite full of page object methods—some possibly unused or outdated—you’ve got two solid paths to gather usage data: static code analysis (scanning your test files without running them) and dynamic tracing (tracking methods as tests execute). Here’s a breakdown of actionable, RSpec-specific approaches to get you the insights you need:

This is the fastest way to get a baseline of method usage, perfect if you don’t want to wait for your full test suite to run.

• Grep + Shell Scripting (Quick & Dirty)
  If you want a no-frills solution, use grep to scan your test files for references to each page object method. Just adjust the paths to match your project structure:

  # Create a CSV to store results
  echo "call_count,method_name,file_path" > method_usage.csv
  
  # Loop through all page object files
  for page_file in app/pages/**/*.rb; do
    # Extract method names (tweak regex if your methods have params or special naming)
    methods=$(grep -E 'def [a-z_][a-z0-9_]*' "$page_file" | sed 's/def //' | tr -d '()')
    for method in $methods; do
      # Count how many times the method is called in test files
      call_count=$(grep -r "$method" spec/features/**/*.rb | wc -l)
      echo "$call_count,$method,$page_file" >> method_usage.csv
    done
  done
  

  Import the CSV into Excel, Google Sheets, or a tool like csvkit to sort by call count. Methods with 0 calls are prime candidates for removal, and the top 20-30 are your most active ones.
  Pro tip: Watch out for false positives (e.g., method names appearing in strings). For better accuracy, pair this with a quick spot-check of low-count methods.

• Ruby Parser Gem (Precise Static Scanning)
  To avoid grep’s limitations, use the parser gem to parse your Ruby code and identify actual method calls (not just string matches). First, add gem 'parser' to your Gemfile and run bundle install. Then use this script:

  require 'parser/current'
  
  # Step 1: Extract all defined page object methods
  page_methods = {}
  Dir.glob('app/pages/**/*.rb').each do |file|
    ast = Parser::CurrentRuby.parse(File.read(file))
    ast.each_node(:def) do |node|
      method_name = node.name.to_s
      page_methods[method_name] ||= []
      page_methods[method_name] << file
    end
  end
  
  # Step 2: Count method calls in test files
  usage_counts = Hash.new(0)
  Dir.glob('spec/features/**/*.rb').each do |file|
    ast = Parser::CurrentRuby.parse(File.read(file))
    ast.each_node(:send) do |node|
      method_name = node.method_name.to_s
      usage_counts[method_name] += 1 if page_methods.key?(method_name)
    end
  end
  
  # Step 3: Output sorted results
  puts "=== Top 30 Active Methods ==="
  usage_counts.sort_by { |_, count| -count }.first(30).each do |method, count|
    puts "#{count} calls: #{method} (defined in: #{page_methods[method].join(', ')})"
  end
  
  puts "\n=== Unused Methods ==="
  page_methods.keys.each do |method|
    puts "- #{method} (defined in: #{page_methods[method].join(', ')})" if usage_counts[method] == 0
  end
  

  This will give you a precise list of which methods are called (and where) without false positives.

Static analysis can miss dynamic calls (e.g., using send(method_name) to invoke methods). Dynamic tracing tracks methods as they actually execute, giving you the most accurate usage data.

• Monkey Patching Page Object Base Class
  Add tracking code to your base page object class to count every method call during test runs. Here’s how:

  # Add this to your base page class (e.g., app/pages/base_page.rb)
  module MethodTracker
    def self.included(base)
      base.extend(ClassMethods)
      base.class_eval { @call_counts = Hash.new(0) }
    end
  
    module ClassMethods
      def call_counts
        @call_counts
      end
    end
  
    # Track existing methods by aliasing them
    def self.track_method(method_name)
      alias_method "original_#{method_name}", method_name
      define_method(method_name) do |*args, &block|
        self.class.call_counts[method_name] += 1
        send("original_#{method_name}", *args, &block)
      end
    end
  end
  
  # Include the tracker in your base page class
  class BasePage
    include MethodTracker
  
    # Track all existing instance methods
    instance_methods(false).each do |method|
      MethodTracker.track_method(method)
    end
  end
  

  Then add a hook to spec_helper.rb to output results after the test suite finishes:

  RSpec.configure do |config|
    config.after(:suite) do
      all_counts = Hash.new(0)
      
      # Aggregate counts from all page classes
      ObjectSpace.each_object(Class) do |klass|
        next unless klass < BasePage && klass.respond_to?(:call_counts)
        klass.call_counts.each do |method, count|
          all_counts[method] += count
        end
      end
  
      # Print top active methods
      puts "\n=== Top 30 Active Methods (Runtime) ==="
      all_counts.sort_by { |_, count| -count }.first(30).each do |method, count|
        puts "#{count} calls: #{method}"
      end
  
      # Print unused methods (cross-reference with defined methods)
      defined_methods = Dir.glob('app/pages/**/*.rb').flat_map do |file|
        Parser::CurrentRuby.parse(File.read(file)).each_node(:def).map(&:name).map(&:to_s)
      end.uniq
      unused_methods = defined_methods - all_counts.keys
      
      puts "\n=== Unused Methods (Runtime) ==="
      unused_methods.each { |method| puts "- #{method}" }
    end
  end
  

  Run your full test suite, and you’ll get a precise runtime usage report.

• Ruby TracePoint API (Non-Invasive Tracing)
  If you don’t want to modify your page object code, use Ruby’s built-in TracePoint API to track method calls:

  # Add this to spec_helper.rb
  method_counts = Hash.new(0)
  trace = TracePoint.new(:call) do |tp|
    # Only track methods from page object classes (adjust regex to match your class names)
    if tp.self.class.name.end_with?('Page')
      method_counts[tp.method_id.to_s] += 1
    end
  end
  
  trace.enable
  
  RSpec.configure do |config|
    config.after(:suite) do
      trace.disable
      
      # Get all defined page methods (using parser gem as before)
      require 'parser/current'
      defined_methods = Dir.glob('app/pages/**/*.rb').flat_map do |file|
        Parser::CurrentRuby.parse(File.read(file)).each_node(:def).map(&:name).map(&:to_s)
      end.uniq
  
      # Output results
      puts "\n=== Top 30 Active Methods ==="
      method_counts.sort_by { |_, count| -count }.first(30).each do |method, count|
        puts "#{count} calls: #{method}"
      end
  
      puts "\n=== Unused Methods ==="
      (defined_methods - method_counts.keys).each { |method| puts "- #{method}" }
    end
  end
  

  This is completely non-invasive—no changes to your page object code required.

• Validate Unused Methods: Don’t delete methods with 0 calls immediately. Some might be used in test branches you don’t run often (e.g., environment-specific tests) or be reserved for future features. Spot-check a few before deleting.
• Safe Deletion: Comment out unused methods first, then run your full test suite to confirm nothing breaks. Once verified, delete them and commit the change to version control (so you can roll back if needed).
• Document Active Methods: Keep the list of top 20-30 active methods handy—this can help new team members prioritize which methods to learn, and inform future refactoring efforts.

内容的提问来源于stack exchange，提问作者Denamix