fixture_farm 0.3.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: daad4947f4b3dd8d77b82001fbfae78d4b0dc3b94cd12c996b512ca858601765
-  data.tar.gz: e6ab57fb99a71d94f479031c79cb1cb24b56aa48a66f10083d3c532699bbe894
+  metadata.gz: 728eb6b44d1deb4df01e4bc03795758f3846e169f6dc07f0f5c7a6a799881976
+  data.tar.gz: 59fe50410c6fd317537dd653001f8bd8e7b571b2375faa97d95e6dc41e188e76
 SHA512:
-  metadata.gz: 3b6bc2b81e6c365c56d0de9b1077afeae0297826bdb4bad11303bacca060b27ea733fba751be6d25d8261bb5d192817d3e7d64c3bfc6ea29757365d0ed373d5f
-  data.tar.gz: 7a05a132020e9792d8b41e65f9bbdf48c62d0e3801943f6a3f59ae186ed79343b01a3d0ac24c003164ad55534a3b97c35b654127ff2c6be932767cbb92abfb64
+  metadata.gz: cd4e4c6609afbe0a09413cf19d71eec01b9366f4e2d793190b8cb9b7aa86eecded615cbeae5daf31036cd3ca6a4bfea42c3bc568236aa9c4c3357b9e81157052
+  data.tar.gz: 2210cb7393ce70c90d3e0225ba28f9b87ee2f4b6d1d106ce029e352b475b6c1c3eed78c1af4bd15e864330101f0059a06ec2f5c65415faf1228a44e03bcf8693

data/README.md

@@ -1,17 +1,19 @@
 # FixtureFarm
 
 This gem lets you do two things:
-
+- record fixtures for a block of code (e.g. part of a test).
 - record fixtures as you browse.
-- record fixtures for a block of code (e.g. setup part of a test).
 
-Generated fixture that `belongs_to` a record from an existing fixture, will reference that fixture by name.
+A few things to note:
+- generated fixture names are based on their `belongs_to` fixture names.
+- generated fixture that `belongs_to` a record from an existing fixture, will reference that fixture by name.
+- models, destroyed during recording, will be removed from fixtures (if they were originally there).
+- generated `ActiveStorage::Blob` fixtures file names, will be the same as fixture names (so they can be generated multiple times, without generating new file each time).
 
 ### Limitations
 
 - doesn't update fixtures
-- doesn't delete fixtures
-- assumes that all serialized attributes are json (so that at least ActiveStorage::Blob metadata is correctly represented; it really should be Rails serializing attributes according to their respective coders when inserting fixtures into the database, but, alas, this isn't happening)
+- assumes that all serialized attributes are json (so that at least ActiveStorage::Blob metadata is correctly represented; it really should be Rails serializing attributes according to their respective coders when inserting fixtures into the database, but, alas, this isn't how it works)
 
 ## Installation
 
@@ -66,11 +68,11 @@ To record in tests, wrap some code in `record_new_fixtures` block. For example:
 include FixtureFarm::TestHelper
 
 test 'some stuff does the right thing' do
-  record_new_fixtures do |stop_recording|
+  record_new_fixtures do |recorder|
     user = User.create!(name: 'Bob')
     post = user.posts.create!(title: 'Stuff')
 
-    stop_recording.call
+    recorder.stop!
 
     assert_difference 'user.published_posts.size' do
       post.publish!

data/Rakefile

@@ -1,8 +1,10 @@
-require "bundler/setup"
+# frozen_string_literal: true
 
-require "bundler/gem_tasks"
+require 'bundler/setup'
 
-require "rake/testtask"
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
 
 Rake::TestTask.new(:test) do |t|
   t.libs << 'test'

data/bin/fixture_farm.rb

@@ -11,9 +11,15 @@ end
 case ARGV[0]
 when 'record'
   FixtureFarm::FixtureRecorder.start_recording_session!(ARGV[1])
-  puts 'Recording fixtures' + (ARGV[1].nil? ? '' : " with prefix #{ARGV[1]}")
+  puts "Recording fixtures#{" with prefix #{ARGV[1]}" unless ARGV[1].nil?}"
 when 'status'
-  puts "Recording is #{FixtureFarm::FixtureRecorder.recording_session_in_progress? ? 'on' : 'off'}"
+  if FixtureFarm::FixtureRecorder.recording_session_in_progress?
+    puts 'Recording is on'
+  elsif (error = FixtureFarm::FixtureRecorder.last_session_error)
+    puts "Recording is off (#{error})"
+  else
+    puts 'Recording is off'
+  end
 when 'stop'
   FixtureFarm::FixtureRecorder.stop_recording_session!
   puts 'Stopped recording'

data/lib/fixture_farm/active_record_extension.rb

@@ -17,14 +17,12 @@ module FixtureFarm
       existing_fixtures_file_path || candidate_fixtures_file_path
     end
 
+    private
+
     def candidate_fixtures_file_path
       klass = self.class
-      loop do
-        path = Rails.root.join('test', 'fixtures', "#{klass.to_s.underscore.pluralize}.yml")
-        return path if klass >= ActiveRecord::Base || !klass.columns.map(&:name).include?(klass.inheritance_column)
 
-        klass = klass.superclass
-      end
+      Rails.root.join('test', 'fixtures', "#{klass.to_s.underscore.pluralize}.yml")
     end
 
     def existing_fixtures_file_path
@@ -32,6 +30,7 @@ module FixtureFarm
 
       while klass < ActiveRecord::Base
         path = Rails.root.join('test', 'fixtures', "#{klass.to_s.underscore.pluralize}.yml")
+
         return path if File.exist?(path)
 
         klass = klass.superclass

data/lib/fixture_farm/controller_hook.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "fixture_farm/hook"
+require 'fixture_farm/hook'
 
 module FixtureFarm
   module ControllerHook

data/lib/fixture_farm/fixture_recorder.rb

@@ -1,89 +1,161 @@
 # frozen_string_literal: true
 
 module FixtureFarm
-  mattr_accessor :low_priority_parent_model_for_naming, default: -> { false }
+
+  mattr_accessor :low_priority_parent_model_for_naming
 
   class FixtureRecorder
-    STORE_PATH = Rails.root.join('tmp', 'fixture_farm_store.json')
+    attr_accessor :new_blob_file_paths
+
+    def self.store_path
+      Rails.root.join('tmp', 'fixture_farm_store.json')
+    end
+
+    def store_path
+      self.class.store_path
+    end
 
     def initialize(fixture_name_prefix, new_models = [])
       @fixture_name_prefix = fixture_name_prefix
       @new_models = new_models
+      @deleted_models = {}
       @initial_now = Time.zone.now
-      @ignore_while_tree_walking = Set.new
+      @named_new_fixtures = {}
+      @existing_fixtures_cache = {}
     end
 
     def self.resume_recording_session
       start_recording_session! unless recording_session_in_progress?
 
-      recording_session = JSON.load_file(STORE_PATH, permitted_classes: [ActiveSupport::HashWithIndifferentAccess])
+      recording_session = load_recording_session
 
       new_models = recording_session['new_models'].map do |(class_name, id)|
         class_name.constantize.find(id)
       end
 
       new(recording_session['fixture_name_prefix'], new_models)
+    rescue ActiveRecord::RecordNotFound
+      # External interference with database (e.g. fixtures:load)
+      recording_session['error'] = 'database was externally modified/reset'
+      File.write(store_path, recording_session.to_json)
+      nil
     end
 
     def self.start_recording_session!(fixture_name_prefix)
-      File.write(STORE_PATH, {
+      File.write(store_path, {
         fixture_name_prefix: fixture_name_prefix,
         new_models: []
       }.to_json)
     end
 
     def self.stop_recording_session!
-      FileUtils.rm_f(STORE_PATH)
+      FileUtils.rm_f(store_path)
     end
 
     def self.recording_session_in_progress?
-      File.exist?(STORE_PATH)
+      recording_session = load_recording_session
+      return false unless recording_session
+
+      !recording_session['error']
+    end
+
+    def self.load_recording_session
+      return nil unless File.exist?(store_path)
+
+      JSON.load_file(store_path, permitted_classes: [ActiveSupport::HashWithIndifferentAccess])
+    end
+
+    def self.last_session_error
+      recording_session = load_recording_session
+      return nil unless recording_session
+
+      recording_session['error']
     end
 
     def record_new_fixtures
-      stopped = false
+      @stopped = false
 
-      subscriber = ActiveSupport::Notifications.subscribe 'sql.active_record' do |event|
+      @subscriber = ActiveSupport::Notifications.subscribe 'sql.active_record' do |event|
         payload = event.payload
 
-        next unless payload[:name] =~ /([:\w]+) Create/
+        if payload[:name] =~ /([:\w]+) Create/
+          new_fixture_class_name = Regexp.last_match(1)
 
-        new_fixture_class_name = Regexp.last_match(1)
+          payload[:connection].transaction_manager.current_transaction.records.reject(&:persisted?).reject(&:destroyed?).each do |model_instance|
+            next if new_fixture_class_name != model_instance.class.name
 
-        payload[:connection].transaction_manager.current_transaction.records.reject(&:persisted?).reject(&:destroyed?).each do |model_instance|
-          next if new_fixture_class_name != model_instance.class.name
+            @new_models << model_instance
+          end
+        elsif payload[:name] =~ /([:\w]+) Destroy/
+          payload[:connection].transaction_manager.current_transaction.records.each do |model|
+            fixture_name = existing_fixture_name(model)
 
-          @new_models << model_instance
+            @deleted_models[fixture_name] = model if fixture_name
+          end
         end
       end
 
-      yield lambda {
-        ActiveSupport::Notifications.unsubscribe(subscriber)
-        stopped = true
-        reload_models
-        update_fixture_files(named_new_fixtures)
-      }
+      yield self
 
-      unless stopped
-        reload_models
-        update_fixture_files(named_new_fixtures)
-      end
+      stop! unless @stopped
     ensure
-      ActiveSupport::Notifications.unsubscribe(subscriber)
+      ActiveSupport::Notifications.unsubscribe(@subscriber)
+    end
+
+    def stop!
+      ActiveSupport::Notifications.unsubscribe(@subscriber)
+      @stopped = true
+      reload_new_models
+      rename_active_storage_blobs_for_idempotency
+      delete_fixtures_for_deleted_models
+      update_fixture_files(named_new_fixtures)
     end
 
     def update_recording_session
       return unless FixtureRecorder.recording_session_in_progress?
 
-      File.write(STORE_PATH, {
+      File.write(store_path, {
         fixture_name_prefix: @fixture_name_prefix,
         new_models: @new_models.map { |model| [model.class.name, model.id] }
       }.to_json)
     end
 
+    def named_new_fixtures
+      @new_models.uniq.each do |model_instance|
+        ensure_new_fixture_name(model_instance)
+      end
+
+      @named_new_fixtures
+    end
+
     private
 
-    def reload_models
+    def rename_active_storage_blobs_for_idempotency
+      self.new_blob_file_paths = named_new_fixtures.filter_map do |fixture_name, model|
+        next unless model.is_a?(ActiveStorage::Blob)
+
+        rename_blob_file_for_idempotency(fixture_name, model)
+      end
+    end
+
+    def rename_blob_file_for_idempotency(fixture_name, blob)
+      old_key = blob.key
+      new_key = fixture_name
+
+      blob.update!(key: new_key)
+
+      from_path = Rails.root.join('storage', old_key[0..1], old_key[2..3], old_key)
+      to_dir = Rails.root.join('storage', new_key[0..1], new_key[2..3])
+      to_path = to_dir.join(new_key)
+
+      `mkdir -p #{to_dir}`
+
+      `mv #{from_path} #{to_path}`
+
+      to_path
+    end
+
+    def reload_new_models
       @new_models = @new_models.map do |model_instance|
         # reload in case model was updated after initial create
         model_instance.reload
@@ -94,28 +166,6 @@ module FixtureFarm
       end.compact
     end
 
-    def named_new_fixtures
-      @named_new_fixtures ||= begin
-                                (@new_models - @ignore_while_tree_walking.to_a).uniq(&:id).each_with_object({}) do |model_instance, named_new_fixtures|
-                                  @ignore_while_tree_walking.add(model_instance)
-
-                                  new_fixture_name = [
-                                    @fixture_name_prefix,
-                                    first_belongs_to_fixture_name(model_instance),
-                                    "#{model_instance.class.name.underscore.split('/').last}_1"
-                                  ].select(&:present?).join('_')
-
-                                  while named_new_fixtures[new_fixture_name]
-                                    new_fixture_name = new_fixture_name.sub(/_(\d+)$/, "_#{Regexp.last_match(1).to_i + 1}")
-                                  end
-
-                                  named_new_fixtures[new_fixture_name] = model_instance
-
-                                  @ignore_while_tree_walking.delete(model_instance)
-                                end
-                              end
-    end
-
     def first_belongs_to_fixture_name(model_instance)
       low_priority_name = nil
 
@@ -124,13 +174,13 @@ module FixtureFarm
 
         next unless associated_model_instance
 
-        if (associated_model_instance_fixture_name = fixture_name(associated_model_instance))
-          if FixtureFarm.low_priority_parent_model_for_naming.call(associated_model_instance)
-            low_priority_name = associated_model_instance_fixture_name
-          else
-            return associated_model_instance_fixture_name
-          end
+        next unless (associated_model_instance_fixture_name = ensure_new_fixture_name(associated_model_instance))
+
+        unless FixtureFarm.low_priority_parent_model_for_naming&.call(associated_model_instance)
+          return associated_model_instance_fixture_name
         end
+
+        low_priority_name = associated_model_instance_fixture_name
       end
 
       low_priority_name
@@ -216,7 +266,7 @@ module FixtureFarm
       if value.to_datetime.minute == 59
         value += 1.minute
         value = value.beginning_of_hour
-      elsif value.to_datetime.minute == 1 || value.to_datetime.minute == 0
+      elsif [1, 0].include?(value.to_datetime.minute)
         value = value.beginning_of_hour
       end
       value
@@ -275,10 +325,74 @@ module FixtureFarm
       end.except(:value_rest)
     end
 
+    def delete_fixtures_for_deleted_models
+      # TODO: optimize
+      @deleted_models.each do |fixture_name, deleted_model|
+        fixtures_file_path = deleted_model.fixtures_file_path
+
+        fixtures = YAML.load_file(fixtures_file_path, permitted_classes: [ActiveSupport::HashWithIndifferentAccess]) || {}
+
+        if fixtures.delete(fixture_name)
+          if fixtures.empty?
+            File.delete(fixtures_file_path)
+          else
+            File.open(fixtures_file_path, 'w') do |file|
+              yaml = YAML.dump(fixtures).gsub(/\n(?=[^\s])/, "\n\n").delete_prefix("---\n\n")
+              file.write(yaml)
+            end
+          end
+        end
+      end
+    end
+
+    def existing_fixtures_for_model(model_instance)
+      model_class = model_instance.class
+
+      return @existing_fixtures_cache[model_class] if @existing_fixtures_cache.key?(model_class)
+
+      fixtures_file_path = model_instance.fixtures_file_path
+
+      @existing_fixtures_cache[model_class] = if File.exist?(fixtures_file_path)
+                                                YAML.load_file(
+                                                  fixtures_file_path,
+                                                  permitted_classes: [ActiveSupport::HashWithIndifferentAccess]
+                                                ) || {}
+                                              else
+                                                {}
+                                              end
+    end
+
+    def ensure_new_fixture_name(model_instance)
+      fixture_name(model_instance) || begin
+        existing_fixtures = existing_fixtures_for_model(model_instance)
+
+        new_fixture_name = [
+          first_belongs_to_fixture_name(model_instance).presence || @fixture_name_prefix,
+          "#{model_instance.class.name.underscore.split('/').last}_1"
+        ].select(&:present?).join('_')
+
+        while @named_new_fixtures[new_fixture_name] || existing_fixtures[new_fixture_name] && !@deleted_models[new_fixture_name]
+          new_fixture_name = new_fixture_name.sub(/_(\d+)$/, "_#{Regexp.last_match(1).to_i + 1}")
+        end
+
+        @named_new_fixtures[new_fixture_name] = model_instance
+
+        new_fixture_name
+      end
+    end
+
+    def existing_fixture_name(model_instance)
+      existing_fixtures = existing_fixtures_for_model(model_instance)
+
+      existing_fixtures.keys.find do |key|
+        ActiveRecord::FixtureSet.identify(key) == model_instance.id
+      end
+    end
+
     def fixture_name(model_instance)
-      named_new_fixtures.find do |_, fixture_model|
+      @named_new_fixtures.find do |_, fixture_model|
         fixture_model.id == model_instance.id
-      end&.first || model_instance.fixture_name
+      end&.first || existing_fixture_name(model_instance)
     end
   end
 end

data/lib/fixture_farm/hook.rb

@@ -1,14 +1,18 @@
 # frozen_string_literal: true
 
-require "fixture_farm/fixture_recorder"
+require 'fixture_farm/fixture_recorder'
 
 module FixtureFarm
   module Hook
     def record_new_fixtures(&block)
       fixture_recorder = FixtureRecorder.resume_recording_session
-      fixture_recorder.record_new_fixtures { block.call }
-    ensure
-      fixture_recorder.update_recording_session
+      return unless fixture_recorder # Bail if session was stopped due to error
+
+      begin
+        fixture_recorder.record_new_fixtures { block.call }
+      ensure
+        fixture_recorder.update_recording_session
+      end
     end
 
     private

data/lib/fixture_farm/test_helper.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "fixture_farm/fixture_recorder"
+require 'fixture_farm/fixture_recorder'
 
 module FixtureFarm
   module TestHelper

data/lib/fixture_farm/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FixtureFarm
-  VERSION = '0.3.1'
+  VERSION = '1.0.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fixture_farm
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 1.0.0
 platform: ruby
 authors:
 - artemave
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-07-09 00:00:00.000000000 Z
+date: 2025-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -52,6 +52,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/featurist/fixture_farm
   source_code_uri: https://github.com/featurist/fixture_farm.git
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths: