fixture_farm 0.3.1 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: daad4947f4b3dd8d77b82001fbfae78d4b0dc3b94cd12c996b512ca858601765
-  data.tar.gz: e6ab57fb99a71d94f479031c79cb1cb24b56aa48a66f10083d3c532699bbe894
+  metadata.gz: af9b30c58737a261963da35795445aadfcb38efe2f3ed6d4fc8055f19399b0df
+  data.tar.gz: 865e73ba12d379aba2b3f48a160ce421efe7d49a958db72f19b185d4d1045175
 SHA512:
-  metadata.gz: 3b6bc2b81e6c365c56d0de9b1077afeae0297826bdb4bad11303bacca060b27ea733fba751be6d25d8261bb5d192817d3e7d64c3bfc6ea29757365d0ed373d5f
-  data.tar.gz: 7a05a132020e9792d8b41e65f9bbdf48c62d0e3801943f6a3f59ae186ed79343b01a3d0ac24c003164ad55534a3b97c35b654127ff2c6be932767cbb92abfb64
+  metadata.gz: 9c1950bc97570624b27f2f928ec82586816429e1f7a34378f5336c83d8d420180ad65093677744a4b6efa8e3cbc2b7a298631837dbb9ffc32d0c11941d372596
+  data.tar.gz: 455b1430edd5fb21874e7cd906688ea55ea3e1753c0e02b13b2bcd051f2e68f17d02174f6b770cac9b15f212cef0923b52c3584f40f7b1d662957cff1a4c0cc3

data/README.md

@@ -1,17 +1,20 @@
 # 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).
+- AR models gain `#fixture_name` method
 
 ### 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
 
@@ -59,82 +62,85 @@ bundle exec fixture_farm stop
 
 ### Record in tests
 
-To record in tests, wrap some code in `record_new_fixtures` block. For example:
+To record in tests, wrap some code in `record_fixtures` block. For example:
 
 ```ruby
 
 include FixtureFarm::TestHelper
 
-test 'some stuff does the right thing' do
-  record_new_fixtures do |stop_recording|
-    user = User.create!(name: 'Bob')
-    post = user.posts.create!(title: 'Stuff')
-
-    stop_recording.call
+test 'parents fixtures have children' do
+  offending_records = Parent.where.missing(:children)
 
-    assert_difference 'user.published_posts.size' do
-      post.publish!
+  if ENV['GENERATE_FIXTURES']
+    record_fixtures do
+      offending_records.each do |parent|
+        parent.children.create!(name: 'Bob')
+      end
     end
+  else
+    assert_empty offending_records.map(&:fixture_name),
+      "The following parents don't have children:"
   end
 end
 ```
 
-Running this test generates user and post fixtures. Now you can rewrite this test to use them:
-
-```ruby
-test 'some stuff does the right thing' do
-  user = users('user_1')
+Assuming there was a parent fixture `dave` that didn't have any children, this test will fail. Now, running the same test with `GENERATE_FIXTURES=1` will generate one child fixture named `dave_child_1`. The test is now passing.
 
-  assert_difference 'user.published_posts.size' do
-    user.posts.first.publish!
-  end
-end
-```
+`record_fixtures` accepts optional name prefix, that applies to all new fixture names.
 
-`record_new_fixtures` accepts optional name prefix, that applies to all new fixture names.
+### Automatic fixture naming
 
-A more robust approach is to have dedicated fixture tests that normally fail, but can be optionally run in "record mode" (think VCR).
+Generated fixture names are based on the first `belongs_to` association of the model. E.g., if a new post fixtures belongs_to to a user fixture `bob`, the name is going to be `bob_post_1`.
 
-For example, let's say we have `Author` model that `has_many :posts` and we require authors to have at least one post. Here's the test to enforce `authors` fixtures to comply with this rule:
+It's possible to lower the priority of given parent assiciations when it comes to naming, so that certain names are only picked when there are no other suitable parent associations. This is useful, for example, to exclude `acts_as_tenant` association:
 
 ```ruby
-test 'authors fixtures must have at least one post' do
-  offending_records = Author.where.missing(:posts)
-
-  assert_empty offending_records
-end
+FixtureFarm.low_priority_parent_model_for_naming = -> { _1.is_a?(TenantModel) }
 ```
 
-Let's say this test is currently failing.
+### Attachment fixtures
 
-Now let's add the option to automatically record missing fixtures:
-
-```ruby
-test 'authors fixtures must have at least one post' do
-  offending_records = Author.where.missing(:posts)
+Rather than [manually crafting attachment fixtures](https://guides.rubyonrails.org/v8.0/active_storage_overview.html#adding-attachments-to-fixtures), we can get the gem do the leg work. Not only is this less boring, but it's also going to generate variant fixtures.
 
-  if ENV['RECORD_FIXTURES']
-    record_new_fixtures do
-      offending_records.each do |author|
-        author.posts.create!(text: 'some text')
-      end
-    end
-  end
+I'd also go as far as suggesting that attachment files for generated blobs should be checked into git just as the fixtures themselves are. To share them with the development environment (e.g. `rails db:fixtures:load`), let's store test attachment files in the same `./storage` directory used in development:
 
-  assert_empty offending_records
-end
+```ruby
+# config/environments/test.rb
+config.active_storage.service = :local
 ```
 
-Running this test with `RECORD_FIXTURES=1` will generate missing fixture entries in `test/fixtures/posts.yml`. Now re-run the test again and it's passing.
-
-### Automatic fixture naming
+Now this test will not only generate attachments and variant fixtures, but also `git add` new attachment files. The old removed ones will show up in `git status`.
 
-Generated fixture names are based on the first `belongs_to` association of the model. E.g., if a new post fixtures belongs_to to a user fixture `bob`, the name is going to be `bob_post_1`.
+```ruby
+test "product fixtures have images" do
+  offending_records = Product.where.missing(:images_attachments)
+
+  if ENV["GENERATE_FIXTURES"]
+    # Makes generation idempotent
+    `git restore --staged storage`
+
+    record_fixtures do |recorder|
+      ActiveStorage::Attachment.where(record_type: 'Product').destroy_all
+
+      Product.find_each do |product|
+        product.images.attach(
+          io: File.open(file_fixture("products/#{product.fixture_name}.jpg")),
+          filename: "#{product.fixture_name}.jpg",
+          content_type: "image/jpeg"
+        )
+        # This generates variants
+        perform_enqueued_jobs
+      end
 
-It's possible to lower the priority of given parent assiciations when it comes to naming, so that certain names are only picked when there are no other suitable parent associations. This is useful, for example, to exclude `acts_as_tenant` association:
+      recorder.stop!
 
-```ruby
-FixtureFarm.low_priority_parent_model_for_naming = -> { _1.is_a?(TenantModel) }
+      `git add -f #{recorder.new_blob_file_paths.join(' ')}`
+    end
+  else
+    assert_empty offending_records.map(&:fixture_name),
+      "Expected the following product fixtures to have images:"
+  end
+end
 ```
 
 ## License

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_job_hook.rb

@@ -8,7 +8,7 @@ module FixtureFarm
     include Hook
 
     included do
-      around_perform :record_new_fixtures, if: :record_new_fixtures?
+      around_perform :record_fixtures, if: :record_fixtures?
     end
   end
 end

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
@@ -8,7 +8,7 @@ module FixtureFarm
     include Hook
 
     included do
-      around_action :record_new_fixtures, if: :record_new_fixtures?
+      around_action :record_fixtures, if: :record_fixtures?
     end
   end
 end

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
+    def record_fixtures
+      @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,19 +1,23 @@
 # frozen_string_literal: true
 
-require "fixture_farm/fixture_recorder"
+require 'fixture_farm/fixture_recorder'
 
 module FixtureFarm
   module Hook
-    def record_new_fixtures(&block)
+    def record_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_fixtures { block.call }
+      ensure
+        fixture_recorder.update_recording_session
+      end
     end
 
     private
 
-    def record_new_fixtures?
+    def record_fixtures?
       FixtureRecorder.recording_session_in_progress?
     end
   end

data/lib/fixture_farm/test_helper.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require "fixture_farm/fixture_recorder"
+require 'fixture_farm/fixture_recorder'
 
 module FixtureFarm
   module TestHelper
-    def record_new_fixtures(fixture_name_prefix = nil, &block)
-      FixtureRecorder.new(fixture_name_prefix).record_new_fixtures(&block)
+    def record_fixtures(fixture_name_prefix = nil, &block)
+      FixtureRecorder.new(fixture_name_prefix).record_fixtures(&block)
     end
   end
 end

data/lib/fixture_farm/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FixtureFarm
-  VERSION = '0.3.1'
+  VERSION = '1.0.1'
 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.1
 platform: ruby
 authors:
 - artemave
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-07-09 00:00:00.000000000 Z
+date: 2025-07-29 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: