fixture_farm 1.0.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 728eb6b44d1deb4df01e4bc03795758f3846e169f6dc07f0f5c7a6a799881976
-  data.tar.gz: 59fe50410c6fd317537dd653001f8bd8e7b571b2375faa97d95e6dc41e188e76
+  metadata.gz: d3a39068e7447367066d1947cf1f14d16366d10e88e91ae922ff3953b7667ff5
+  data.tar.gz: 7f28f26923b51368511ed5ef8c55531f2d405ba36d11ea802caedbc554fbcf0a
 SHA512:
-  metadata.gz: cd4e4c6609afbe0a09413cf19d71eec01b9366f4e2d793190b8cb9b7aa86eecded615cbeae5daf31036cd3ca6a4bfea42c3bc568236aa9c4c3357b9e81157052
-  data.tar.gz: 2210cb7393ce70c90d3e0225ba28f9b87ee2f4b6d1d106ce029e352b475b6c1c3eed78c1af4bd15e864330101f0059a06ec2f5c65415faf1228a44e03bcf8693
+  metadata.gz: 84a8649ace5e14d8dd09b94cdde3d15f02ebd8bd602f706b48ec48f9bff9ab4ea0170fd26827886ee8b0595909d930ce16e61d21e422df9b9e9a7c545df248b7
+  data.tar.gz: d25f84374a79d33ee8ee117656c59e7523d4087dd3dc9065de7a540b882b5cd2fd9897e4aee3aa23af3a8f0eb43ee5168efb2d390dc12ecbde8b1a3b0fd22656

data/README.md

@@ -9,6 +9,7 @@ A few things to note:
 - 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
 
@@ -54,89 +55,127 @@ include FixtureFarm::ActiveJobHook if defined?(FixtureFarm)
 Then start/stop recording using tasks:
 
 ```bash
-bundle exec fixture_farm record some_awesome_name_prefix
+bundle exec fixture_farm record
+# OR
+bundle exec fixture_farm record name_prefix
+# OR
+bundle exec fixture_farm record name_prefix:replaces_name
+
 bundle exec fixture_farm status
 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 |recorder|
-    user = User.create!(name: 'Bob')
-    post = user.posts.create!(title: 'Stuff')
-
-    recorder.stop!
+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:
+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.
 
-```ruby
-test 'some stuff does the right thing' do
-  user = users('user_1')
+`record_fixtures` accepts optional name prefix, that applies to all new fixture names.
 
-  assert_difference 'user.published_posts.size' do
-    user.posts.first.publish!
-  end
+#### Fixture Name Replacement
+
+`record_fixtures` also supports hash arguments for advanced fixture naming control:
+
+```ruby
+# Replace 'client_1' with 'new_client' in fixture names, or use 'new_client' as prefix if not found
+record_fixtures(new_client: :client_1) do
+  User.create!(name: 'Test User', email: 'test@example.com')
 end
 ```
 
-`record_new_fixtures` accepts optional name prefix, that applies to all new fixture names.
+This works in two ways:
+- **Replacement**: If a generated fixture name contains `client_1`, it gets replaced with `new_client`
+- **Prefixing**: If a generated fixture name doesn't contain `client_1`, it gets prefixed with `new_client_`
+
+For example:
+- A user fixture that would be named `client_1_user_1` becomes `new_client_user_1` (replacement)
+- A user fixture that would be named `user_1` becomes `new_client_user_1` (prefixing)
 
-A more robust approach is to have dedicated fixture tests that normally fail, but can be optionally run in "record mode" (think VCR).
+### Automatic fixture naming
 
-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:
+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 'authors fixtures must have at least one post' do
-  offending_records = Author.where.missing(:posts)
+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:
 
-  assert_empty offending_records
-end
+```ruby
+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:
+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 to do the work. Not only is this less boring, but it's also going to generate variant fixtures.
 
-```ruby
-test 'authors fixtures must have at least one post' do
-  offending_records = Author.where.missing(:posts)
+If we then check the generated blob files into git (along with the fixture files themselves), no attachment processing will be happening in tests or after `rails db:fixtures:load`.
 
-  if ENV['RECORD_FIXTURES']
-    record_new_fixtures do
-      offending_records.each do |author|
-        author.posts.create!(text: 'some text')
-      end
-    end
-  end
+We'll need a special storage service for the fixture blobs we want to keep versioned. For example:
 
-  assert_empty offending_records
-end
+```yml
+# config/storage.yml
+test_fixtures:
+  service: Disk
+  root: <%= Rails.root.join("test/fixtures/files/active_storage_blobs") %>
 ```
 
-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.
+Now a test like the one below is either going to fail if some product fixtures have no attachments, or, if run with `GENERATE_FIXTURES=1`, is going to generate those attachment fixtures, their variant fixtures if needed, along with all the blob files tucked away in a separate (from regular throw away storage) folder that can be checked in:
 
-### Automatic fixture naming
+```ruby
+if ENV["GENERATE_FIXTURES"]
+  setup do
+    @original_queue_adapter = Rails.configuration.active_job.queue_adapter
+    # This is so that variants get generated and blobs analyzed
+    Rails.configuration.active_job.queue_adapter = :inline
+
+    @original_storage_service = ActiveStorage::Blob.service
+    ActiveStorage::Blob.service = ActiveStorage::Blob.services.fetch(:test_fixtures)
+  end
 
-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`.
+  teardown do
+    Rails.configuration.active_job.queue_adapter = @original_queue_adapter
+    ActiveStorage::Blob.service = @original_storage_service
+  end
+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:
+test "product fixtures have images" do
+  offending_records = Product.where.missing(:images_attachments)
 
-```ruby
-FixtureFarm.low_priority_parent_model_for_naming = -> { _1.is_a?(TenantModel) }
+  if ENV["GENERATE_FIXTURES"]
+    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"
+        )
+      end
+    end
+  else
+    assert_empty offending_records.map(&:fixture_name),
+      "Expected the following product fixtures to have images:"
+  end
+end
 ```
 
 ## License

data/bin/fixture_farm.rb

@@ -4,14 +4,24 @@
 require_relative '../lib/fixture_farm/fixture_recorder'
 
 def usage
-  puts 'Usage: bundle exec fixture_farm <record|status|stop> [fixture_name_prefix]'
+  puts 'Usage: bundle exec fixture_farm <record|status|stop> [name_prefix|name_prefix:replaces_name]'
   exit 1
 end
 
 case ARGV[0]
 when 'record'
-  FixtureFarm::FixtureRecorder.start_recording_session!(ARGV[1])
-  puts "Recording fixtures#{" with prefix #{ARGV[1]}" unless ARGV[1].nil?}"
+  prefix_arg = ARGV[1]
+
+  # Parse hash syntax like "new_user:user_1" into {new_user: :user_1}
+  if prefix_arg&.include?(':')
+    parts = prefix_arg.split(':', 2)
+    parsed_prefix = { parts[0].to_sym => parts[1].to_sym }
+  else
+    parsed_prefix = prefix_arg
+  end
+
+  FixtureFarm::FixtureRecorder.start_recording_session!(parsed_prefix)
+  puts "Recording fixtures#{" with prefix #{prefix_arg}" unless prefix_arg.nil?}"
 when 'status'
   if FixtureFarm::FixtureRecorder.recording_session_in_progress?
     puts 'Recording is on'

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/controller_hook.rb

@@ -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,7 +1,6 @@
 # frozen_string_literal: true
 
 module FixtureFarm
-
   mattr_accessor :low_priority_parent_model_for_naming
 
   class FixtureRecorder
@@ -16,7 +15,13 @@ module FixtureFarm
     end
 
     def initialize(fixture_name_prefix, new_models = [])
-      @fixture_name_prefix = fixture_name_prefix
+      if fixture_name_prefix.is_a?(Hash)
+        @fixture_name_replacements = fixture_name_prefix
+        @fixture_name_prefix = nil
+      else
+        @fixture_name_prefix = fixture_name_prefix
+        @fixture_name_replacements = {}
+      end
       @new_models = new_models
       @deleted_models = {}
       @initial_now = Time.zone.now
@@ -72,7 +77,7 @@ module FixtureFarm
       recording_session['error']
     end
 
-    def record_new_fixtures
+    def record_fixtures
       @stopped = false
 
       @subscriber = ActiveSupport::Notifications.subscribe 'sql.active_record' do |event|
@@ -95,9 +100,11 @@ module FixtureFarm
         end
       end
 
-      yield self
+      result = yield self
 
       stop! unless @stopped
+
+      result
     ensure
       ActiveSupport::Notifications.unsubscribe(@subscriber)
     end
@@ -144,8 +151,10 @@ module FixtureFarm
 
       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])
+      blobs_root_path = Pathname.new(ActiveStorage::Blob.service.root)
+
+      from_path = blobs_root_path.join(old_key[0..1], old_key[2..3], old_key)
+      to_dir = blobs_root_path.join(new_key[0..1], new_key[2..3])
       to_path = to_dir.join(new_key)
 
       `mkdir -p #{to_dir}`
@@ -366,12 +375,25 @@ module FixtureFarm
       fixture_name(model_instance) || begin
         existing_fixtures = existing_fixtures_for_model(model_instance)
 
-        new_fixture_name = [
+        base_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]
+        @fixture_name_replacements.each do |new_name, old_name|
+          # Only apply replacement if the base_name doesn't already start with new_name
+          # This prevents double-application of replacements
+          next if base_name.start_with?("#{new_name}_")
+
+          original_name = base_name
+          base_name = base_name.gsub(/\b#{Regexp.escape(old_name.to_s)}\b/, new_name.to_s)
+
+          # If no replacement occurred, use new_name as prefix
+          base_name = "#{new_name}_#{base_name}" if base_name == original_name
+        end
+
+        new_fixture_name = base_name
+        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
 

data/lib/fixture_farm/hook.rb

@@ -4,12 +4,12 @@ require 'fixture_farm/fixture_recorder'
 
 module FixtureFarm
   module Hook
-    def record_new_fixtures(&block)
+    def record_fixtures(&block)
       fixture_recorder = FixtureRecorder.resume_recording_session
       return unless fixture_recorder # Bail if session was stopped due to error
 
       begin
-        fixture_recorder.record_new_fixtures { block.call }
+        fixture_recorder.record_fixtures { block.call }
       ensure
         fixture_recorder.update_recording_session
       end
@@ -17,7 +17,7 @@ module FixtureFarm
 
     private
 
-    def record_new_fixtures?
+    def record_fixtures?
       FixtureRecorder.recording_session_in_progress?
     end
   end

data/lib/fixture_farm/test_helper.rb

@@ -4,8 +4,8 @@ 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,5 +1,5 @@
 # frozen_string_literal: true
 
 module FixtureFarm
-  VERSION = '1.0.0'
+  VERSION = '1.1.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fixture_farm
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.1
 platform: ruby
 authors:
 - artemave
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-07-28 00:00:00.000000000 Z
+date: 2025-08-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails