real_data_tests 0.2.1 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a8d2dd0beed227113467c6660eaa2101c603ef7c127ad3bd7fb19c835a641b1b
-  data.tar.gz: ac0e5fdb541110b7a523a6fa8a894d49d1c10ab9eeab86003f9ae13ebbf1968a
+  metadata.gz: 1c5ba3c2d2b4bb4f9ec9a6c539ddd809b6840d3eb7e6cbfb33d02f524177b3ff
+  data.tar.gz: e64f18ddd2a0bab9c0f3aad9ab628fb7bd86097644807c5d99596aa3c3af55c4
 SHA512:
-  metadata.gz: e048bb72149153484dc179e7628ea3fc41e083906e7cbbd8c1a970b147aa1a232c5d32a6d26553de22c8c3b21a281913515bf1c51b43700c80ba0ac3dc35ffe6
-  data.tar.gz: 3859be802e7aea039691af38cc309bb56c81832bb5740d510e9f6438d10873a66d1efa8aae167a8cdc2a7e3f24b8b4c26f92d2481303d948797bbbd6a5d08d4d
+  metadata.gz: 14a8d12cb5fd01582b2bf22d47d7fa518f2f0be2258e15c477f42c29c1c95b9d362fc20f486fe583f655eeac5b15ceba48c888eb49e9bc47444ab3ffcf79feb6
+  data.tar.gz: 1c2a99d52fa1b740c07152bf12d6802711bba8af8af38d94924d66ddda06d2eab76e6f459b532af3c29e2a0767bfd4ee7977aa23293b3a616225a5b340010a89

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 ## [Unreleased]
 
+## [0.3.1] - 2025-01-14
+### Fixed
+- Fixed circular dependency handling in RecordCollector to correctly limit record collection
+  - Moved prevention logic earlier in the collection process to stop circular dependencies before record collection
+  - Improved tracking of visited associations for more accurate prevention
+  - Added better logging for dependency prevention decisions
+  - Fixed test case for circular dependency prevention in nested associations
+
+## [0.3.0] - 2025-01-13
+### Added
+- **Polymorphic Association Support**:
+  - RecordCollector now supports tracking and collecting records from polymorphic associations.
+  - Polymorphic `belongs_to`, `has_many`, and `has_one` associations are automatically detected and processed during data collection.
+  - Added tracking for polymorphic types in `@collection_stats` to provide detailed insights into polymorphic relationships.
+  - Graceful handling of missing records in polymorphic associations using error logging.
+
+### Fixed
+- Improved error handling for `ActiveRecord::RecordNotFound` exceptions when loading polymorphic associations.
+- Correctly initializes and updates association statistics for polymorphic associations in `@collection_stats`.
+
 ## [0.2.1] - 2025-01-13
 ### Fixed
 - Fixed JSONB field handling to output '{}' instead of empty string for blank values

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    real_data_tests (0.2.0)
+    real_data_tests (0.2.1)
       activerecord (>= 5.0)
       faker (~> 3.0)
       pg (>= 1.1)

data/README.md

@@ -90,6 +90,37 @@ Rails.application.config.after_initialize do
 end
 ```
 
+## Polymorphic Association Support
+
+Real Data Tests supports collecting records through polymorphic associations. This feature allows you to:
+- Automatically detect and collect records for polymorphic `belongs_to`, `has_many`, and `has_one` associations.
+- Track and report the types of records collected through polymorphic associations in detailed collection statistics.
+
+### Example
+If your model includes a polymorphic association like this:
+
+```ruby
+class Payment < ApplicationRecord
+  belongs_to :billable, polymorphic: true
+end
+```
+
+Real Data Tests will:
+1. Collect the associated `billable` records regardless of their type (e.g., `InsuranceCompany`, `Patient`).
+2. Include the `billable_type` in the collection statistics for transparency and reporting.
+
+### Configuration for Polymorphic Associations
+Polymorphic associations are automatically handled based on your existing configuration. You can also explicitly include or limit polymorphic associations, like so:
+
+```ruby
+RealDataTests.configure do |config|
+  config.include_associations_for 'Payment', :billable
+  config.limit_association 'Payment.billable', 5
+end
+```
+
+This ensures a robust and flexible way to handle even the most complex relationships in your data.
+
 ## Using Presets
 
 Real Data Tests allows you to define multiple configuration presets for different data extraction needs. This is particularly useful when you need different association rules and anonymization settings for different testing scenarios.
@@ -268,6 +299,22 @@ This is particularly useful when:
 - You want to collect an association from one model but not another
 - You need to maintain a clean separation of concerns in your test data
 
+### Polymorphic Associations
+Polymorphic associations are fully supported. Include and configure them as needed:
+
+```ruby
+RealDataTests.configure do |config|
+  config.include_associations_for 'Payment', :billable
+end
+```
+
+You can also limit or prevent reciprocal loading for polymorphic associations:
+
+```ruby
+config.limit_association 'Payment.billable', 10
+config.prevent_reciprocal 'Payment.billable'
+```
+
 ### Association Loading Control
 
 You can further refine how associations are loaded using limits and reciprocal prevention:

data/lib/real_data_tests/configuration.rb

@@ -61,7 +61,10 @@ module RealDataTests
   class PresetConfig
     attr_reader :association_filter_mode, :association_filter_list,
                 :model_specific_associations, :association_limits,
-                :prevent_reciprocal_loading, :anonymization_rules
+                :prevent_reciprocal_loading, :anonymization_rules,
+                :prevented_reciprocals
+
+    attr_accessor :max_depth
 
     def initialize
       @association_filter_mode = nil
@@ -70,6 +73,26 @@ module RealDataTests
       @association_limits = {}
       @prevent_reciprocal_loading = {}
       @anonymization_rules = {}
+      @prevented_reciprocals = Set.new
+      @max_depth = 10
+    end
+
+    def prevent_circular_dependency(klass, association_name)
+      key = if klass.is_a?(String)
+        "#{klass}:#{association_name}"
+      else
+        "#{klass.name}:#{association_name}"
+      end
+      @prevented_reciprocals << key
+    end
+
+    def has_circular_dependency?(klass, association_name)
+      key = if klass.is_a?(String)
+        "#{klass}:#{association_name}"
+      else
+        "#{klass.name}:#{association_name}"
+      end
+      @prevented_reciprocals.include?(key)
     end
 
     def include_associations(*associations)
@@ -102,9 +125,14 @@ module RealDataTests
       @association_limits[path]
     end
 
+    def set_association_limit(model_name, association_name, limit)
+      path = "#{model_name}.#{association_name}"
+      @association_limits[path] = limit
+    end
+
     def prevent_reciprocal?(record_class, association_name)
       path = "#{record_class.name}.#{association_name}"
-      @prevent_reciprocal_loading[path]
+      @prevent_reciprocal_loading[path] || has_circular_dependency?(record_class, association_name)
     end
 
     def prevent_reciprocal(path)

data/lib/real_data_tests/record_collector.rb

@@ -1,84 +1,182 @@
 module RealDataTests
   class RecordCollector
+    attr_reader :collection_stats, :collected_records
+
     def initialize(record)
       @record = record
       @collected_records = Set.new
-      @collection_stats = Hash.new { |h, k| h[k] = { count: 0, associations: Hash.new(0) } }
+      @collection_stats = {}
       @processed_associations = Set.new
       @association_path = []
+      @current_depth = 0
+      @visited_associations = {}
+
+      # Initialize stats for the record's class
+      @collection_stats[record.class.name] = {
+        count: 0,
+        associations: Hash.new(0),
+        polymorphic_types: {}
+      }
+
+      record.class.reflect_on_all_associations(:belongs_to).each do |assoc|
+        if assoc.polymorphic?
+          @collection_stats[record.class.name][:polymorphic_types][assoc.name.to_s] ||= Set.new
+        end
+      end
+
+      puts "\nInitializing RecordCollector for #{record.class.name}##{record.id}"
+      record.class.reflect_on_all_associations(:belongs_to).each do |assoc|
+        if assoc.polymorphic?
+          type = record.public_send("#{assoc.name}_type")
+          id = record.public_send("#{assoc.name}_id")
+          puts "Found polymorphic belongs_to '#{assoc.name}' with type: #{type}, id: #{id}"
+        end
+      end
     end
 
     def collect
       puts "\nStarting record collection from: #{@record.class.name}##{@record.id}"
-      filter_mode = RealDataTests.configuration.association_filter_mode
-      filter_list = RealDataTests.configuration.association_filter_list
+      filter_mode = RealDataTests.configuration.current_preset.association_filter_mode
+      filter_list = RealDataTests.configuration.current_preset.association_filter_list
       puts "Using #{filter_mode || 'no'} filter with #{filter_list.any? ? filter_list.join(', ') : 'no associations'}"
-      collect_record(@record)
+      collect_record(@record, 0)
       print_collection_stats
       @collected_records.to_a
     end
 
     private
 
-    def should_process_association?(record, association)
-      association_key = "#{record.class.name}##{record.id}:#{association.name}"
-      return false if @processed_associations.include?(association_key)
-      @processed_associations.add(association_key)
-
-      # Use the enhanced should_process_association? method
-      return false unless RealDataTests.configuration.should_process_association?(record, association.name)
-
-      # Check for prevented reciprocal loading
-      if RealDataTests.configuration.prevent_reciprocal?(record.class, association.name)
-        puts "  Skipping prevented reciprocal association: #{association.name} on #{record.class.name}"
-        return false
-      end
-
-      true
-    end
-
-    def collect_record(record)
+    def collect_record(record, depth)
       return if @collected_records.include?(record)
       return unless record # Guard against nil records
+      return if depth > RealDataTests.configuration.current_preset.max_depth
 
+      puts "\nCollecting record: #{record.class.name}##{record.id}"
       @collected_records.add(record)
+
+      # Initialize stats structure
+      @collection_stats[record.class.name] ||= {
+        count: 0,
+        associations: {},
+        polymorphic_types: {}
+      }
       @collection_stats[record.class.name][:count] += 1
-      collect_associations(record)
+
+      # Track types for polymorphic belongs_to associations
+      record.class.reflect_on_all_associations(:belongs_to).each do |assoc|
+        next unless assoc.polymorphic?
+
+        type = record.public_send("#{assoc.name}_type")
+        @collection_stats[record.class.name][:polymorphic_types][assoc.name.to_sym] ||= Set.new
+
+        begin
+          associated_record = record.public_send(assoc.name)
+          if associated_record
+            puts "  Adding polymorphic type '#{type}' for #{assoc.name}"
+            @collection_stats[record.class.name][:polymorphic_types][assoc.name.to_sym] << associated_record.class.name
+          else
+            puts "  Skipping polymorphic type for #{assoc.name} due to missing associated record"
+          end
+        rescue StandardError => e
+          puts "  Error loading polymorphic association #{assoc.name}: #{e.message}"
+        end
+      end
+
+      collect_associations(record, depth)
     end
 
-    def collect_associations(record)
+    def collect_associations(record, depth)
       return unless record.class.respond_to?(:reflect_on_all_associations)
+      return if depth >= RealDataTests.configuration.current_preset.max_depth
 
       associations = record.class.reflect_on_all_associations
       puts "\nProcessing associations for: #{record.class.name}##{record.id}"
       puts "Found #{associations.length} associations"
 
       associations.each do |association|
-        should_process = RealDataTests.configuration.should_process_association?(record, association.name)
+        association_key = "#{record.class.name}##{record.id}:#{association.name}"
+        puts "  Checking if should process: #{association_key}"
 
-        unless should_process
-          puts "  Skipping #{RealDataTests.configuration.association_filter_mode == :whitelist ? 'non-whitelisted' : 'blacklisted'} association: #{association.name} for #{record.class.name}"
-          next
+        if RealDataTests.configuration.current_preset.prevent_reciprocal?(record.class, association.name)
+          track_key = "#{record.class.name}:#{association.name}"
+          @visited_associations[track_key] ||= Set.new
+
+          # Skip if we've already processed this association type for this class
+          if @visited_associations[track_key].any?
+            puts "    Skipping prevented reciprocal association: #{track_key}"
+            next
+          end
+          @visited_associations[track_key].add(record.id)
         end
 
-        puts "  Processing #{association.macro} association: #{association.name}"
-        process_association(record, association)
+        next unless should_process_association?(record, association, depth)
+
+        puts "  Processing #{association.macro} #{association.polymorphic? ? 'polymorphic ' : ''}association: #{association.name}"
+        process_association(record, association, depth)
       end
     end
 
-    def process_association(record, association)
+    def should_process_association?(record, association, depth = 0)
+      return false if depth >= RealDataTests.configuration.current_preset.max_depth
+
+      association_key = "#{record.class.name}##{record.id}:#{association.name}"
+      return false if @processed_associations.include?(association_key)
+
+      # Check if the association is allowed by configuration
+      should_process = RealDataTests.configuration.current_preset.should_process_association?(record, association.name)
+      puts "  Configuration says: #{should_process}"
+
+      if should_process
+        @processed_associations.add(association_key)
+        true
+      else
+        false
+      end
+    end
+
+    def process_association(record, association, depth)
+      @association_path.push(association.name)
+
       begin
+        if detect_circular_dependency?(record, association)
+          puts "    Skipping circular dependency for #{association.name} on #{record.class.name}##{record.id}"
+          return
+        end
+
         related_records = fetch_related_records(record, association)
         count = related_records.length
         puts "    Found #{count} related #{association.name} records"
-        @collection_stats[record.class.name][:associations][association.name] += count
 
-        related_records.each { |related_record| collect_record(related_record) }
+        @collection_stats[record.class.name][:associations][association.name.to_s] ||= 0
+        @collection_stats[record.class.name][:associations][association.name.to_s] += count
+
+        related_records.each { |related_record| collect_record(related_record, depth + 1) }
       rescue => e
         puts "    Error processing association #{association.name}: #{e.message}"
+      ensure
+        @association_path.pop
       end
     end
 
+    def self_referential_association?(klass, association)
+      return false unless association.options[:class_name]
+      return false if association.polymorphic?
+      association.options[:class_name] == klass.name
+    end
+
+    def detect_circular_dependency?(record, association)
+      return false unless association.belongs_to?
+      return false if association.polymorphic?
+
+      target_class = association.klass
+      return false unless target_class
+
+      path_key = "#{target_class.name}:#{association.name}"
+      visited_count = @association_path.count { |assoc| "#{target_class.name}:#{assoc}" == path_key }
+
+      visited_count > 1
+    end
+
     def fetch_related_records(record, association)
       case association.macro
       when :belongs_to, :has_one
@@ -86,13 +184,12 @@ module RealDataTests
       when :has_many, :has_and_belongs_to_many
         relation = record.public_send(association.name)
 
-        # Apply configured limit if it exists
-        if limit = RealDataTests.configuration.get_association_limit(record.class, association.name)
-          puts "  Applying configured limit of #{limit} records for #{record.class.name}.#{association.name}"
-          relation = relation.limit(limit)
+        if limit = RealDataTests.configuration.current_preset.get_association_limit(record.class, association.name)
+          puts "    Applying configured limit of #{limit} records for #{record.class.name}.#{association.name}"
+          relation = relation[0...limit]
         end
 
-        relation.loaded? ? relation.to_a : relation.load.to_a
+        relation
       else
         []
       end
@@ -103,12 +200,20 @@ module RealDataTests
       @collection_stats.each do |model, stats|
         puts "\n#{model}:"
         puts "  Total records: #{stats[:count]}"
+
         if stats[:associations].any?
           puts "  Associations:"
           stats[:associations].each do |assoc_name, count|
             puts "    #{assoc_name}: #{count} records"
           end
         end
+
+        if stats[:polymorphic_types].any?
+          puts "  Polymorphic Types:"
+          stats[:polymorphic_types].each do |assoc_name, types|
+            puts "    #{assoc_name}: #{types.to_a.join(', ')}"
+          end
+        end
       end
       puts "\nTotal unique records collected: #{@collected_records.size}"
       puts "==============================\n"

data/lib/real_data_tests/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RealDataTests
-  VERSION = "0.2.1"
+  VERSION = "0.3.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: real_data_tests
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.1
 platform: ruby
 authors:
 - Kevin Dias
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-01-13 00:00:00.000000000 Z
+date: 2025-01-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails