fixture_champagne 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c999bd5772d62cce811ec251c0a6703a58bd7daf7b31d6d00ed08fe80f9133f
-  data.tar.gz: 1bb147d5724d90fd9341b480b449218e71827ab00e694bc6c10d1ffaa99bda59
+  metadata.gz: df7d52e3ca9af49027da830311f500968199eedca0af5cf43f37c15d14c323ae
+  data.tar.gz: b0d33d41c4f49d83e2471b5c7c0d3d30e8e98eac7a333b70461d27a462a34a88
 SHA512:
-  metadata.gz: b0a14630348c2e463ca683801cc72be51e9e8b65466a1fb73143072a486979991484dc6d2c80fe081287821d4afa8570c45ec4f33c13f4d2996a22c2202021f4
-  data.tar.gz: 6c6e4d55bf6654cee801ca4545f052351f4ef81505921240e1e007d362e12e9c050f22cc3f9305c566b8946b7fd81831309dce87f00619266c35bd2263cf3bd5
+  metadata.gz: 3d1aaa2fbe30d236f8f7ce8fa06e989b2b20864d5a8cc02d708a037843c3337859c566edc1067da36eb921651654f9943d75e27440b9ffa87a1f7e69e5e96585
+  data.tar.gz: cb33035170df7e2bd01586a2023cb832a3213f534a1ed43677fb44c7d264afa6e9e570b0d63425a06be832d765b5cd5618ab3cd98fa5218fa053ccc2d6898738

data/README.md

@@ -2,6 +2,8 @@
 
 ### Fixture migrations for your Ruby on Rails applications
 
+[![Build Status](https://github.com/jguecaimburu/fixture_champagne/workflows/Tests/badge.svg)](https://github.com/jguecaimburu/fixture_champagne/actions) [![Gem Version](https://badge.fury.io/rb/fixture_champagne.svg)](https://badge.fury.io/rb/fixture_champagne)
+
 
 Fixture Champagne is designed to help you keep your fixtures tidy, applying the data migration pattern to create, update or destroy fixtures.
 
@@ -92,7 +94,7 @@ Add the `up` and `down` logic to the new migration:
 class CreateInitialEnemy < FixtureChampagne::Migration::Base
   def up
     unless Enemy.find_by(name: "Initial Enemy").present?
-      Enemy.create!(name: "Initial Enemy", level: levels(:first_level)) 
+      Enemy.create!(name: "Initial Enemy", level: levels(:first_level))
     end
   end
 
@@ -114,8 +116,9 @@ enemies_12345678:
 
 If the migration is successful, the migrator will take the max version all available migrations and the current schema version and save both numbers in `test/.fixture_champagne_versions.yml` (or `spec/` if using Rspec) to identify future pending migrations.
 
-The default label for a new fixture is a unique identifier composed of the table name and the record id. However, this label can be configured (keep reading to know how).
+The default label for a new fixture is a unique identifier composed of the table name and the record id. However, this label can be [configured](#fixture-labels).
 
+You can also customize your fixture migrations by overriding the default template. Just place yours in `lib/templates/fixture_champagne/migration/migration.rb.tt`. This can be useful for example if you use [FactoryBot](#extending-your-migrations).
 
 ### Rollback
 
@@ -136,6 +139,9 @@ You can better control fixture migrations by creating a config YAML file: `test/
 
 Setting the `overwrite` key to `false` will leave your current fixtures untouched. The generated fixtures will go to `tmp/fixtures`. Default value is set to `true`.
 
+This feature has partial support for multiple fixture paths (Rails > 7.1). If your fixtures are divided across multiple paths (for example `test/fixtures_a` and `test/fixtues_b`), the fixture migration will fail unless you set `overwrite` to `false`. However, if you set multiple folders but only use one (all your files are in `test/fixtures_a`) then the migration can overwrite that folder.
+
+
 ```yaml
 # test/fixture_champagne.yml
 
@@ -152,7 +158,7 @@ In the previous example, you can configure:
 # test/fixture_champagne.yml
 
 label:
-  enemy: "%{name}"    
+  enemy: "%{name}"
 ```
 
 To generate:
@@ -181,7 +187,7 @@ If `rename` is set to `true`, every time you run `migrate` or `rollback` all fix
 
 Setting the `ignore` key will allow you to control which tables get saved as fixtures. It accepts an array, where items are table names. Any table ignored by this configuration will disappear from the corresponding fixture folder (depending on `overwrite`).
 
-Let's say for example that each time a new `Enemy` gets created, it creates an associated `Event` in a callback that runs some processing in the background. If that event belongs to a polymorphic `eventable`, for every single one of those, a new event will be added to your fixtures, making the `events.yml` a big but not very useful file. Or maybe events get incinerated a couple of days after execution and it makes no sense to have fixtures for them. In any of those situations, you could ignore them from fixtures like this:  
+Let's say for example that each time a new `Enemy` gets created, it creates an associated `Event` in a callback that runs some processing in the background. If that event belongs to a polymorphic `eventable`, for every single one of those, a new event will be added to your fixtures, making the `events.yml` a big but not very useful file. Or maybe events get incinerated a couple of days after execution and it makes no sense to have fixtures for them. In any of those situations, you could ignore them from fixtures like this:
 
 ```yaml
 # test/fixture_champagne.yml
@@ -207,6 +213,45 @@ If you use single table inheritance, then the file will correspond with the pare
 All fixtures files that correspond to attachments will be copied as they are. Those are the ones located in `fixtures/files`, `fixtures/active_storage` and `fixtures/action_text`.
 
 
+### Extending your migrations
+
+You can customize your fixture migrations by overriding the default template. Just place yours in `lib/templates/fixture_champagne/migration/migration.rb.tt`. Let's say you use [FactoryBot](https://github.com/thoughtbot/factory_bot_rails). It could be really helpful to use your existing factories to create new fixtures.
+
+You could replace the default template with:
+```ruby
+require "factory_bot_rails"
+
+class <%= class_name %> < FixtureChampagne::Migration::Base
+  include FactoryBot::Syntax::Methods
+
+  def up
+    # Create, update or destroy records here
+  end
+
+  def down
+    # Optionally, reverse changes made by the :up method
+  end
+end
+```
+
+And all your migrations will now have access to your existing factories. If you have an enemy factory, the new migration could look like:
+```ruby
+# 20230126153650_create_initial_enemy.rb
+
+class CreateInitialEnemy < FixtureChampagne::Migration::Base
+  def up
+    unless Enemy.find_by(name: "Initial Enemy").present?
+      create(:enemy, name: "Initial Enemy", level: levels(:first_level))
+    end
+  end
+
+  def down
+    Enemy.find_by(name: "Initial Enemy").destroy!
+  end
+end
+```
+
+
 ## Features currently not supported
 
 The following fixture features are not supported:
@@ -217,6 +262,7 @@ The following fixture features are not supported:
 - Fixture label interpolation (favoured configuration)
 - HABTM (`have_and_belong_to_many`) associations as inline lists
 - Support for YAML defaults (this could be nice)
+- Overwriting multiple fixture paths
 
 As stated before, at least for now, fixtures files that correspond to attachments will be copied as they are. This means:
 - This fixtures must be generated manually

data/lib/fixture_champagne/migration_context.rb

@@ -4,7 +4,7 @@ module FixtureChampagne
   # MigrationContext sets the context in which a fixture migration is run.
   #
   # A migration context checks where the application files are located, which could be
-  # in /test if the app uses Minitest or /spec if the app uses Rspec, and from that base
+  # in /test if the app uses Minitest or /spec if the app uses RSpec, and from that base
   # it decides where everything else is located:
   # - Fixture migrations folder
   # - Configuration YAML file
@@ -14,8 +14,13 @@ module FixtureChampagne
   # With all that it decides which migrations are pending, which are executed and the target
   # versions. Depending on the method called, it also decides the direction the Migrator should execute.
   class MigrationContext
+    MINITEST_PATH = Rails.root.join("test")
+    RSPEC_PATH = Rails.root.join("spec")
+
     class << self
       def migrate
+        raise NotInTestEnvironmentError unless Rails.env.test?
+
         build_context.migrate
       end
 
@@ -44,18 +49,19 @@ module FixtureChampagne
       end
 
       def test_suite_folder_path
-        rspec_path = Rails.root.join("test")
-        minitest_path = Rails.root.join("spec")
-
-        if minitest_path.exist?
-          minitest_path
-        elsif rspec_path.exist?
-          rspec_path
+        if test_framework == :rspec && RSPEC_PATH.exist?
+          RSPEC_PATH
+        elsif MINITEST_PATH.exist?
+          MINITEST_PATH
         else
-          raise "No test nor spec folder found"
+          raise "No test nor spec folder found. Tried: #{[MINITEST_PATH, RSPEC_PATH].to_json}"
         end
       end
 
+      def test_framework
+        ::Rails.application.config.generators.options[:rails][:test_framework]
+      end
+
       def schema_current_version
         ::ActiveRecord::Migrator.current_version
       end
@@ -84,8 +90,21 @@ module FixtureChampagne
         test_suite_folder_path.join("fixture_champagne.yml")
       end
 
-      def fixtures_path
-        test_suite_folder_path.join("fixtures")
+      def fixture_paths
+        paths = if test_framework == :rspec
+                  rspec_fixture_paths
+                else
+                  minitest_fixture_paths
+                end
+        paths.map { |p| Pathname.new(p) }
+      end
+
+      def minitest_fixture_paths
+        MinitestConfig.new(MINITEST_PATH).fixture_paths
+      end
+
+      def rspec_fixture_paths
+        RSpecConfig.new(RSPEC_PATH).fixture_paths
       end
     end
 
@@ -208,5 +227,48 @@ module FixtureChampagne
         @configuration_data["ignore"].to_a || []
       end
     end
+
+    # RSpecConfig loads RSpec configuration
+    class RSpecConfig
+      attr_reader :rspec_path
+
+      def initialize(rspec_path)
+        @rspec_path = rspec_path
+      end
+
+      def fixture_paths
+        $LOAD_PATH.unshift(rspec_path)
+        require "rspec/rails"
+        require_relative rspec_path.join("rails_helper").to_s
+
+        if RSpec.configuration.respond_to?(:fixture_paths=)
+          RSpec.configuration.fixture_paths
+        else
+          Array(RSpec.configuration.fixture_path)
+        end
+      end
+    end
+
+    # MinitestConfig loads Minitest configuration
+    class MinitestConfig
+      attr_reader :minitest_path
+
+      def initialize(minitest_path)
+        @minitest_path = minitest_path
+      end
+
+      def fixture_paths
+        # Monkey patching Minitest to avoid autorun
+        Minitest.define_singleton_method(:autorun) { nil }
+
+        require "rails/test_help"
+
+        if ActiveSupport::TestCase.respond_to?(:fixture_paths=)
+          ActiveSupport::TestCase.fixture_paths
+        else
+          Array(ActiveSupport::TestCase.fixture_path)
+        end
+      end
+    end
   end
 end

data/lib/fixture_champagne/migrator.rb

@@ -14,18 +14,12 @@ module FixtureChampagne
 
     attr_reader :direction, :migrations, :target_migration_version, :target_schema_version, :configuration
 
+    TMP_FIXTURE_PATH = Rails.root.join("tmp", "fixtures")
+
     class << self
       def fixture_unique_id(table_name:, id:)
         "#{table_name}_#{id}"
       end
-
-      def tmp_fixture_path
-        Rails.root.join("tmp", "fixtures")
-      end
-
-      def fixture_attachment_folders
-        %w[files active_storage action_text].map { |f| fixture_path.join(f) }
-      end
     end
 
     def initialize(
@@ -86,7 +80,7 @@ module FixtureChampagne
     end
 
     def build_fixture_data(klasses)
-      data = serialize_database_records(klasses)
+      data = serialize_database_model_instances(klasses)
 
       data.each_with_object({}) do |(table, table_data), sorted_data|
         next if table_data.empty?
@@ -95,7 +89,7 @@ module FixtureChampagne
       end
     end
 
-    def serialize_database_records(klasses)
+    def serialize_database_model_instances(klasses)
       klasses.each_with_object({}) do |klass, hash|
         table_name = klass.table_name.to_s
         if hash.key?(table_name)
@@ -103,21 +97,21 @@ module FixtureChampagne
                 "repeated table key for new fixtures, table #{table_name}, class: #{klass}"
         end
 
-        hash[table_name] = serialize_table_records(klass)
+        hash[table_name] = serialize_table_model_instances(klass)
       end
     end
 
-    def serialize_table_records(klass)
+    def serialize_table_model_instances(klass)
       table_data = {}
 
-      klass.all.each do |record|
-        label = fixture_label(record)
+      klass.all.each do |model_instance|
+        label = fixture_label(model_instance)
         if table_data.key?(label)
           raise RepeatedFixtureError,
                 "repeated fixture in serialization for label #{label}, class #{klass}"
         end
 
-        table_data[label] = fixture_serialized_attributes(record)
+        table_data[label] = fixture_serialized_attributes(model_instance)
       end
 
       table_data
@@ -128,8 +122,8 @@ module FixtureChampagne
       self.class.fixture_unique_id(table_name: fixture_set.table_name, id: fixture.find.id)
     end
 
-    def fixture_label(record)
-      labeler.label_for(record: record)
+    def fixture_label(model_instance)
+      labeler.label_for(model_instance: model_instance)
     end
 
     def labeler
@@ -140,8 +134,8 @@ module FixtureChampagne
       )
     end
 
-    def fixture_serialized_attributes(record)
-      serializer.serialized_attributes_for(record: record)
+    def fixture_serialized_attributes(model_instance)
+      serializer.serialized_attributes_for(model_instance: model_instance)
     end
 
     def serializer
@@ -163,20 +157,24 @@ module FixtureChampagne
     end
 
     def setup_temporary_fixtures_dir
-      FileUtils.rm_r(self.class.tmp_fixture_path, secure: true) if self.class.tmp_fixture_path.exist?
-      FileUtils.mkdir(self.class.tmp_fixture_path)
+      FileUtils.rm_r(TMP_FIXTURE_PATH, secure: true) if TMP_FIXTURE_PATH.exist?
+      FileUtils.mkdir(TMP_FIXTURE_PATH)
     end
 
     def copy_fixture_attachments
-      self.class.fixture_attachment_folders.each do |folder|
-        FileUtils.cp_r(folder, self.class.tmp_fixture_path) if folder.exist?
+      fixture_attachment_folders.each do |folder|
+        FileUtils.cp_r(folder, TMP_FIXTURE_PATH) if folder.exist?
       end
     end
 
+    def fixture_attachment_folders
+      %w[files active_storage action_text].map { |f| effective_fixture_path.join(f) }
+    end
+
     def temporary_fixture_filename(klass)
       parts = klass.to_s.split("::").map(&:underscore)
       parts << parts.pop.pluralize.concat(".yml")
-      self.class.tmp_fixture_path.join(*parts)
+      TMP_FIXTURE_PATH.join(*parts)
     end
 
     def create_temporary_fixture_file(data, filename)
@@ -188,12 +186,36 @@ module FixtureChampagne
     end
 
     def overwrite_fixtures
-      removable_fixture_path = self.class.fixture_path.dirname.join("old_fixtures")
-      FileUtils.mv(self.class.fixture_path, removable_fixture_path)
-      FileUtils.mv(self.class.tmp_fixture_path, self.class.fixture_path)
+      removable_fixture_path = effective_fixture_path.dirname.join("old_fixtures")
+      FileUtils.mv(effective_fixture_path, removable_fixture_path)
+      FileUtils.mv(TMP_FIXTURE_PATH, effective_fixture_path)
       FileUtils.rm_r(removable_fixture_path, secure: true)
     end
 
+    def effective_fixture_path
+      @effective_fixture_path ||= set_effective_fixture_path
+    end
+
+    def set_effective_fixture_path
+      # From Rails 7.1 users can set multiple fixture paths, the default being test/fixtures.
+      # Most users will use the default path. Others may use a custom path but keep the default in the array,
+      # even if they do not use it. For now the gem supports only these 2 cases.
+      # If a user has fixture files in multiple paths, then it's trickier to decide where to save the new
+      # generated fixtures, so for now the gem will not allow these users to overwrite current files.
+
+      paths_with_files = MigrationContext.fixture_paths.select do |path|
+        Dir[::File.join(path, "{**,*}/*.{yml}")].any?
+      end
+
+      if paths_with_files.size > 1 && configuration.overwrite_fixtures?
+        raise OverwriteNotAllowedError,
+              "can't overwrite fixtures when using multiple folders: #{path_with_files.to_json}. Set overwrite to false"
+      end
+
+      # If all folders are still empty, use the first one
+      paths_with_files.first || MigrationContext.fixture_paths
+    end
+
     def remember_new_fixture_versions
       File.open(MigrationContext.fixture_versions_path, "w") do |file|
         yaml = YAML.dump({ "version" => target_migration_version, "schema_version" => target_schema_version })
@@ -211,45 +233,45 @@ module FixtureChampagne
         @rename = rename
       end
 
-      def label_for(record:)
+      def label_for(model_instance:)
         if @rename
-          build_label_for(record)
+          build_label_for(model_instance)
         else
-          find_label_for(record) || build_label_for(record)
+          find_label_for(model_instance) || build_label_for(model_instance)
         end
       end
 
       private
 
-      def find_label_for(record)
-        @pre_existing_fixtures_labels[record_unique_id(record)]
+      def find_label_for(model_instance)
+        @pre_existing_fixtures_labels[model_instance_unique_id(model_instance)]
       end
 
-      def build_label_for(record)
-        template = @templates[record.class.table_name]
+      def build_label_for(model_instance)
+        template = @templates[model_instance.class.table_name]
 
         if template.nil? || template == "DEFAULT"
-          default_label(record)
+          default_label(model_instance)
         else
-          interpolate_template(template, record)
+          interpolate_template(template, model_instance)
         end
       end
 
-      def default_label(record)
-        record_unique_id(record)
+      def default_label(model_instance)
+        model_instance_unique_id(model_instance)
       end
 
-      def record_unique_id(record)
-        Migrator.fixture_unique_id(table_name: record.class.table_name, id: record.id)
+      def model_instance_unique_id(model_instance)
+        Migrator.fixture_unique_id(table_name: model_instance.class.table_name, id: model_instance.id)
       end
 
-      def interpolate_template(template, record)
+      def interpolate_template(template, model_instance)
         template.gsub(INTERPOLATION_PATTERN) do
           attribute = ::Regexp.last_match(1).to_sym
-          value = if record.respond_to?(attribute)
-                    record.send(attribute)
+          value = if model_instance.respond_to?(attribute)
+                    model_instance.send(attribute)
                   else
-                    raise WrongFixtureLabelInterpolationError, attribute: attribute, klass: record.class
+                    raise WrongFixtureLabelInterpolationError, attribute: attribute, klass: model_instance.class
                   end
           value
         end.parameterize(separator: "_")
@@ -264,56 +286,63 @@ module FixtureChampagne
         @labeler = labeler
       end
 
-      def serialized_attributes_for(record:)
-        column_attributes = record.attributes.select { |a| record.class.column_names.include?(a) }
+      def serialized_attributes_for(model_instance:)
+        column_attributes = model_instance.attributes.select { |a| model_instance.class.column_names.include?(a) }
 
         # Favour fixtures autofilled timestamps and autogenerated ids
         filtered_attributes = %w[id created_at updated_at]
 
         serialized_attributes = column_attributes.map do |attribute, value|
-          serialize_attribute(record, attribute, value, filtered_attributes)
+          serialize_attribute(model_instance, attribute, value, filtered_attributes)
         end
 
         serialized_attributes.sort_by(&:first).to_h.except(*filtered_attributes)
       end
 
-      def serialize_attribute(record, attribute, value, filtered_attributes)
-        belongs_to_association = record.class.reflect_on_all_associations.filter(&:belongs_to?).find do |a|
+      def serialize_attribute(model_instance, attribute, value, filtered_attributes)
+        belongs_to_association = model_instance.class.reflect_on_all_associations.filter(&:belongs_to?).find do |a|
           a.foreign_key.to_s == attribute
         end
-        type = record.class.type_for_attribute(attribute)
+        type = model_instance.class.type_for_attribute(attribute)
 
         if belongs_to_association.present?
           filter_belongs_to_columns(belongs_to_association, filtered_attributes)
-          serialize_belongs_to(record, belongs_to_association)
+          serialize_belongs_to(model_instance, belongs_to_association)
         else
-          serialize_type(record, attribute, value, type)
+          serialize_type(model_instance, attribute, value, type)
         end
       end
 
-      def serialize_belongs_to(record, belongs_to_association)
-        associated_record = record.send(belongs_to_association.name)
+      def serialize_belongs_to(model_instance, belongs_to_association)
+        associated_model_instance = model_instance.send(belongs_to_association.name)
 
         reference_label = if belongs_to_association.polymorphic?
-                            foreign_type = record.send(belongs_to_association.foreign_type)
-                            "#{labeler.label_for(record: associated_record)} (#{foreign_type})"
+                            foreign_type = model_instance.send(belongs_to_association.foreign_type)
+                            "#{labeler.label_for(model_instance: associated_model_instance)} (#{foreign_type})"
                           else
-                            labeler.label_for(record: associated_record)
+                            labeler.label_for(model_instance: associated_model_instance)
                           end
 
         [belongs_to_association.name.to_s, reference_label]
       end
 
-      def serialize_type(record, attribute, value, type)
-        if type.type == :datetime
+      # rubocop:disable Metrics/MethodLength
+      def serialize_type(model_instance, attribute, value, type)
+        if type.respond_to?(:scheme) && encrypted_fixtures?
+          [attribute, type.cast_type.serialize(value)]
+        elsif type.type == :datetime
           # ActiveRecord::Type::DateTime#serialize returns a TimeWithZone object that makes the YAML dump less clear
-          [attribute, record.read_attribute_before_type_cast(attribute)]
+          [attribute, model_instance.read_attribute_before_type_cast(attribute)]
+          # PostgreSQL jsonb attributes can be saved as hashes or arrays in fixture yaml files
+        elsif type.type == :jsonb
+          [attribute, value]
         elsif type.respond_to?(:serialize)
           [attribute, type.serialize(value)]
         else
           [attribute, value.to_s]
         end
       end
+      # rubocop:enable Metrics/MethodLength
 
       def filter_belongs_to_columns(belongs_to_association, filtered_attributes)
         filtered_attributes << belongs_to_association.foreign_key.to_s
@@ -321,6 +350,10 @@ module FixtureChampagne
 
         filtered_attributes << belongs_to_association.foreign_type.to_s
       end
+
+      def encrypted_fixtures?
+        Rails.configuration.active_record.encryption.encrypt_fixtures
+      end
     end
   end
 end

data/lib/fixture_champagne/test_fixtures.rb

@@ -11,7 +11,11 @@ module FixtureChampagne
     include ActiveRecord::TestFixtures
 
     included do
-      self.fixture_path = MigrationContext.fixtures_path
+      if respond_to?(:fixture_paths)
+        self.fixture_paths = MigrationContext.fixture_paths
+      else
+        self.fixture_path = MigrationContext.fixture_paths.first
+      end
       fixtures :all
     end
 
@@ -20,9 +24,6 @@ module FixtureChampagne
     end
 
     def before_migrate
-      # Database is already prepared
-      ActiveRecord::TestDatabases.create_and_load_schema(0, env_name: "test") unless Rails.env.test?
-
       setup_fixtures
     end
 

data/lib/fixture_champagne/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FixtureChampagne
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/fixture_champagne.rb

@@ -32,4 +32,8 @@ module FixtureChampagne # :nodoc:
       end
     end
   end
+
+  class NotInTestEnvironmentError < StandardError; end # :nodoc:
+
+  class OverwriteNotAllowedError < StandardError; end # :nodoc:
 end

data/lib/tasks/fixture_champagne_tasks.rake

@@ -4,12 +4,25 @@ require "fixture_champagne"
 
 namespace :fixture_champagne do
   desc "Run Fixture Champagne migrations to update fixtures"
-  task migrate: :environment  do
+  task migrate: :_load_test_environment do
     FixtureChampagne::MigrationContext.migrate
   end
 
   desc "Rollback Fixture Champagne last executed migration"
-  task rollback: :environment do
+  task rollback: :_load_test_environment do
     FixtureChampagne::MigrationContext.rollback
   end
+
+  # HACK: Forces the task to run in the test environment. Rails configs each
+  #       environment differently and this can affect how to handle the database.
+  #       Keeping the migration with the same environment as the tests makes everything
+  #       much simpler.
+  task :_force_test_environment do # rubocop:disable Rake:Desc
+    unless Rails.env.test?
+      tasks = Rake.application.top_level_tasks
+      exec({ "RAILS_ENV" => "test" }, "bin/rails", *tasks)
+    end
+  end
+
+  task _load_test_environment: %i[_force_test_environment environment]
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fixture_champagne
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Juan Gueçaimburu
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-07 00:00:00.000000000 Z
+date: 2023-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails