real_data_tests 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4834f12223bd9db7628aac93a05735a50cb61921313e2bf3b7d496e538dee461
-  data.tar.gz: a8f6de663a143bc42469f953cc64eb49e2f9bc328f70990e885f87be2cac0305
+  metadata.gz: 1db1628bca035d2b5e5f402b39ceaabd5c78b5bf957cd7bcd7856e5819889334
+  data.tar.gz: 477319961d6795bd6005c8d5819cc7d26ded26ba46704cc3bc6ab2c5e701227e
 SHA512:
-  metadata.gz: f00434ab2a006d6a4d0c92263ab160f1cfaf7fd38a110f36bd91280bf00d317708a136cbd2f54d2cc87151a3d9dba3130f4c58c21bb77bcedcc2135690a96179
-  data.tar.gz: 645da39c079e2d1c7953f6588127b3144e98738dbaef82f720b11ea34dbd8dd9a582e0f6d70a0105df3a883a7e78ff2613d61d6c1cc24648e3849a9830b35ae3
+  metadata.gz: 30b473701dfd16d6337803a481caf8e358cf87c04877c076a66b2079da57bd68d0896d321c16c2cf1ecab1ce08b5179aba7f9845b0b28d58ecf9e67fb8d9f2b7
+  data.tar.gz: f0ea756e2384a7d43f5d40a36d018b569fc5abdba092f5635ade2d11ec1bf24a33c1ba219d1d983fbc7a918fbf842bd2a85436a644cc65fa40d2ea0fb07a923d

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 ## [Unreleased]
 
+## [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
+- Added test coverage for JSONB field handling in PgDumpGenerator
+
 ## [0.2.0] - 2025-01-13
 ### Added
 - New preset system for managing different test data configurations

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

@@ -102,6 +102,11 @@ 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]

data/lib/real_data_tests/pg_dump_generator.rb

@@ -138,8 +138,14 @@ module RealDataTests
         value.to_s
       when :boolean
         value.to_s
-      when :array, :json, :jsonb
-        parse_and_format_special_type(value, column_info)
+      when :jsonb, :json
+        if value.blank?
+          "'{}'"  # Return empty JSON object for blank JSONB/JSON fields
+        else
+          sanitize_string(value.is_a?(String) ? value : value.to_json)
+        end
+      when :array
+        parse_and_format_array(value, column_info[:sql_type])
       else
         if column_info[:array]
           parse_and_format_array(value, column_info[:sql_type])

data/lib/real_data_tests/record_collector.rb

@@ -1,11 +1,36 @@
 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 = {}
+
+      # 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
+
       @processed_associations = Set.new
       @association_path = []
+
+      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
@@ -23,26 +48,54 @@ module RealDataTests
     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)
+      puts "  Checking if should process: #{association_key}"
+      should_process = RealDataTests.configuration.should_process_association?(record, association.name)
+      puts "  Configuration says: #{should_process}"
 
-      # 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
+      if should_process
+        @processed_associations.add(association_key)
+        if RealDataTests.configuration.prevent_reciprocal?(record.class, association.name)
+          puts "  Skipping prevented reciprocal association: #{association.name} on #{record.class.name}"
+          return false
+        end
+        true
+      else
+        false
       end
-
-      true
     end
 
     def collect_record(record)
       return if @collected_records.include?(record)
       return unless record # Guard against nil records
 
+      puts "\nCollecting record: #{record.class.name}##{record.id}"
       @collected_records.add(record)
+
+      # Ensure stats structure is initialized
+      @collection_stats[record.class.name] ||= { count: 0, associations: {}, polymorphic_types: {} }
       @collection_stats[record.class.name][:count] += 1
+
+      # 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 ActiveRecord::RecordNotFound => e
+          puts "  Error loading polymorphic association #{assoc.name}: #{e.message}"
+        end
+      end
+
       collect_associations(record)
     end
 
@@ -54,14 +107,9 @@ module RealDataTests
       puts "Found #{associations.length} associations"
 
       associations.each do |association|
-        should_process = RealDataTests.configuration.should_process_association?(record, association.name)
+        next unless should_process_association?(record, association)
 
-        unless should_process
-          puts "  Skipping #{RealDataTests.configuration.association_filter_mode == :whitelist ? 'non-whitelisted' : 'blacklisted'} association: #{association.name} for #{record.class.name}"
-          next
-        end
-
-        puts "  Processing #{association.macro} association: #{association.name}"
+        puts "  Processing #{association.macro} #{association.polymorphic? ? 'polymorphic ' : ''}association: #{association.name}"
         process_association(record, association)
       end
     end
@@ -71,7 +119,8 @@ module RealDataTests
         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
+        @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) }
       rescue => e
@@ -86,13 +135,14 @@ 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}"
+          puts "    Applying configured limit of #{limit} records for #{record.class.name}.#{association.name}"
           relation = relation.limit(limit)
         end
 
-        relation.loaded? ? relation.to_a : relation.load.to_a
+        records = relation.to_a
+        records = records[0...limit] if limit # Ensure in-memory limit as well
+        records
       else
         []
       end
@@ -103,12 +153,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.0"
+  VERSION = "0.3.0"
 end

metadata

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