mongoid-fixture_kit 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6174b5eb254b73dda38a9e2edb58610a7c826e0572178e94059050d850668313
-  data.tar.gz: e227334e2cb880f870f97679e567ebe0bf5a2cd2b37ec4430057e5c8831a1555
+  metadata.gz: fd5ebdcfcdbb7c1e5688c3192bde7bba3d343aaf500a78dd46bf8edaae69ce4e
+  data.tar.gz: 9030d69cf2f9f4b37cdaa53b657e726dd6dd98c8b05c04725077484a3772b7ef
 SHA512:
-  metadata.gz: 6a6e57a38aed49d3a15f51775c59ceb8d68d8d67fcc6ba0dadb2c52a8c43e3acb4ae8cc22358722400d07cc9779a23e8f626c07665428da13c955c9d13b03e8a
-  data.tar.gz: ff02e462158039045a563eb2e4a578176c900d45d56aca15d324ab4453b67af2bcdedc0d9dc2f7c0785c48c024a81309278f1d3b1abd4be644f3747ffea81248
+  metadata.gz: 1ccf73e370a9db3da023420e1b19434f9674ab70d00051c3a5ffb43d6d0567cfa55c3ae116a61bc2e5cef8175b93fdc99a16b749358b032d1c50af36a7626bee
+  data.tar.gz: 13210177d5be94c71337ef9af9d6200c874db77fb42219bd91a23e8c1e4cad6b37e5838c76980ecf669c6813420a60809df849f9471d60574574076d19da4ff4

data/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 Dániel Sipos
+Copyright (c) 2023-2026 Dániel Sipos
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -0,0 +1,175 @@
+# mongoid-fixture_kit
+
+[![Version](https://img.shields.io/gem/v/mongoid-fixture_kit.svg?style=square)](https://rubygems.org/gems/mongoid-fixture_kit)
+[![Download](https://img.shields.io/gem/dt/mongoid-fixture_kit.svg?style=square)](https://rubygems.org/gems/mongoid-fixture_kit)
+[![License](https://img.shields.io/github/license/siposdani87/mongoid-fixture-kit.svg?style=square)](./LICENSE)
+
+<a href="https://www.buymeacoffee.com/siposdani87" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-green.png" alt="Buy Me A Coffee" width="150" height="39" /></a>
+
+This package is a Ruby gem that provides a way to load sample data into a MongoDB database for testing purposes. It provides a simple and convenient way to manage test data by defining fixtures in YAML files, which can be loaded into the database before running tests.
+
+This library aims to provide fixtures for Mongoid the same way you have them with ActiveRecord.
+
+## Getting Started
+
+### Installing
+
+```ruby
+gem 'mongoid-fixture_kit'
+```
+
+### Usage
+
+In your tests, add:
+
+```ruby
+class ActiveSupport::TestCase
+  include Mongoid::FixtureKit::TestHelper
+  self.fixture_path = "#{Rails.root}/test/fixtures"
+end
+```
+
+This is also done by `ActiveRecord`, but magically in the railties.
+
+Then when you want to access a fixture:
+
+```ruby
+class UsersControllerTest < ActionController::TestCase
+  setup do
+    @user = users(:user_1)
+  end
+
+  test 'should show user' do
+    get :show, params: { id: @user }
+    assert_response :success
+  end
+end
+```
+
+### Features
+
+- Creation of a document from a YAML file
+- ERB inside YAML files
+- `$LABEL` interpolation in fixture values
+- `belongs_to` relations
+- Polymorphic `belongs_to`
+- `has_many` relations
+- `has_and_belongs_to_many` relations
+- Embedded documents (`embeds_one`, `embeds_many`)
+- `DEFAULTS` key for shared fixture attributes
+- `TestHelper` module to include in your tests
+
+### ERB in Fixtures
+
+You can use ERB in your YAML fixture files to generate dynamic data:
+
+```yaml
+<% 5.times do |i| %>
+school<%= i %>:
+  name: School <%= i %>
+<% end %>
+```
+
+### Label Interpolation
+
+Use `$LABEL` in fixture values to reference the fixture's own name:
+
+```yaml
+user_john:
+  username: $LABEL
+  email: $LABEL@example.com
+```
+
+This will set `username` to `"user_john"` and `email` to `"user_john@example.com"`.
+
+### Defaults
+
+Use the `DEFAULTS` key to define shared attributes for all fixtures in a file:
+
+```yaml
+DEFAULTS:
+  role: member
+
+admin:
+  name: Admin
+  role: admin
+
+regular_user:
+  name: Regular User
+```
+
+The `DEFAULTS` entry is removed during loading and is not inserted as a document.
+
+### Compatibility
+
+| Dependency | Supported versions |
+|---|---|
+| Ruby | 3.1, 3.2, 3.3, 3.4 |
+| Mongoid | 7.x, 8.x, 9.x |
+| Rails (ActiveSupport) | 7.0+ |
+
+### Notes
+
+Documents are stored with a special attribute `__fixture_name` which is used to retrieve it and establish relations.
+
+`Mongoid::Document` has a `attr_accessor` defined for `__fixture_name`, so it doesn't pose any problem if you try to `dup` a document for example.
+
+### Changes compared to ActiveRecord
+
+- There is an option to load fixtures only once.
+- Fixture accessor methods are defined publicly.
+
+These changes are here to let you create another class holding persistent data inside your tests.
+
+```ruby
+class TestData
+  include Mongoid::FixtureKit::TestHelper
+
+  self.fixture_path = "#{Rails.root}/test/fixtures_universes"
+  self.load_fixtures_once = true
+
+  def TestData.instance
+    @instance ||= ->(){
+      instance = new
+      instance.setup_fixtures
+      instance
+    }.call
+  end
+
+  private_class_method :new
+end
+
+class ActiveSupport::TestCase
+  include Mongoid::FixtureKit::TestHelper
+  self.fixture_path = "#{Rails.root}/test/fixtures"
+
+  def data
+    TestData.instance
+  end
+end
+
+# somewhere else
+test 'should validate complex data structure' do
+  assert_nothing_raised do
+    DataStructure.process(data.structures(:complex))
+  end
+end
+```
+
+## License
+
+The original version of this library is [mongoid-fixture_set](https://github.com/Aethelflaed/mongoid-fixture_set) by Geoffroy Planquart in 2014
+
+## Bugs or Requests
+
+If you encounter any problems feel free to open an [issue](https://github.com/siposdani87/mongoid-fixture-kit/issues/new?template=bug_report.md). If you feel the library is missing a feature, please raise a [ticket](https://github.com/siposdani87/mongoid-fixture-kit/issues/new?template=feature_request.md). Pull request are also welcome.
+
+[![DigitalOcean Referral Badge](https://web-platforms.sfo2.cdn.digitaloceanspaces.com/WWW/Badge%201.svg)](https://www.digitalocean.com/?refcode=b992bb656478&utm_campaign=Referral_Invite&utm_medium=Referral_Program&utm_source=badge)
+
+## Developer
+
+[Dániel Sipos](https://siposdani87.com)
+
+## Sponsors
+
+This project is generously supported by [TrophyMap](https://trophymap.org), [I18Nature](https://i18nature.com), and several other amazing organizations.

data/lib/mongoid/fixture_kit/file.rb

@@ -5,7 +5,7 @@ module Mongoid
     class File
       include Enumerable
 
-      def self.open(file)
+      def self.parse(file)
         x = new(file)
         block_given? ? yield(x) : x
       end

data/lib/mongoid/fixture_kit/fixture.rb

@@ -1,8 +1,6 @@
 module Mongoid
   class FixtureKit
     class Fixture
-      include Enumerable
-
       attr_reader :name, :fixture, :model_class
 
       def initialize(name, fixture, model_class)

data/lib/mongoid/fixture_kit/test_helper.rb

@@ -53,7 +53,7 @@ module Mongoid
 
                 define_method(accessor_name) do |*fixture_names|
                   force_reload = false
-                  force_reload = fixture_names.pop if fixture_names.last == true || fixture_names.last == :reload
+                  force_reload = fixture_names.pop if [true, :reload].include?(fixture_names.last)
                   @fixture_cache[fs_name] ||= {}
                   instances =
                     fixture_names.map do |f_name|

data/lib/mongoid/fixture_kit/util.rb

@@ -44,8 +44,7 @@ module Mongoid
         fixtures_map = {}
         fixture_kits =
           files_to_read.map do |fs_name|
-            fixtures_map[fs_name] =
-              Mongoid::FixtureKit.new(fs_name, class_names[fs_name], ::File.join(fixtures_directory, fs_name))
+            fixtures_map[fs_name] = Mongoid::FixtureKit.new(fs_name, class_names[fs_name], ::File.join(fixtures_directory, fs_name))
           end
 
         update_all_loaded_fixtures(fixtures_map)
@@ -75,6 +74,14 @@ module Mongoid
       def update_document(document, attributes)
         attributes.delete('_id') if document.attributes.key?('_id')
 
+        # Extract embedded document attributes before processing.
+        # In Mongoid 8+, document["field"] = hash (bracket notation) stores the raw hash
+        # but does NOT build the embedded model object, so document.field returns nil.
+        # We handle embedded docs separately: bracket notation + save + reload.
+        embedded_attrs = extract_embedded_attributes(document, attributes)
+        # Temporarily skip extraction for debugging
+        # embedded_attrs = {}
+
         keys = (attributes.keys + document.attributes.keys).uniq
         keys.each do |key|
           value = attributes[key] || document[key]
@@ -88,7 +95,14 @@ module Mongoid
         end
 
         sanitize_new_embedded_documents(document)
+
+        # Save non-embedded attributes first, so embedded attr fallbacks
+        # (which may need to reload) don't lose the non-embedded data.
+        save_document(document) if embedded_attrs.any?
+
+        apply_embedded_attributes(document, embedded_attrs)
         save_document(document)
+
         document
       end
 
@@ -107,25 +121,18 @@ module Mongoid
                (is_new && document[name])
 
               embedded_documents = document.public_send(relation.name)
-              embedded_documents.each_with_index do |embedded_document, i|
-                embedded_document_set_default_values(embedded_document, document[name][i])
+              embedded_documents.each_with_index do |embed_doc, i|
+                embedded_document_set_default_values(embed_doc, document[name][i])
               end
             end
           when :belongs_to
             if is_new && document.attributes[name]
               value = document.attributes.delete(name)
-              if value.is_a?(Hash)
-                raise(
-                  Mongoid::FixtureKit::FixtureError,
-                  'Unable to create nested document inside an embedded document'
-                )
-              end
+              raise(Mongoid::FixtureKit::FixtureError, 'Unable to create nested document inside an embedded document') if value.is_a?(Hash)
 
               doc = find_or_create_document(relation.class_name, value)
               document.attributes[relation.foreign_key] = doc.id
             end
-          else
-            # type code here
           end
         end
       end
@@ -137,7 +144,7 @@ module Mongoid
           document.fields.select do |k, v|
             k != '_id' && v.default_val.present? && attributes[k] == document[k]
           end
-        removable_fields.each do |k, _v|
+        removable_fields.each_key do |k|
           attributes.delete(k)
         end
       end
@@ -149,13 +156,7 @@ module Mongoid
         if document.nil?
           document = model.new
           document['__fixture_name'] = fixture_name
-          begin
-            save_document(document)
-          rescue StandardError => e
-            Rails.logger.debug(document.attributes)
-            Rails.logger.debug(e)
-            Rails.logger.debug { "Backtrace:\n\t#{e.backtrace.join("\n\t")}" }
-          end
+          save_document(document)
         end
         document
       end
@@ -167,22 +168,87 @@ module Mongoid
       end
 
       def collection_documents(fixture_kit)
-        # allow a standard key to be used for doing defaults in YAML
-        fixture_kit.fixtures.delete('DEFAULTS')
-
         # track any join collection we need to insert later
         documents = {}
+        # allow a standard key to be used for doing defaults in YAML
+        fixtures = fixture_kit.fixtures.except('DEFAULTS')
         documents[fixture_kit.class_name] =
-          fixture_kit.fixtures.map do |label, fixture|
+          fixtures.map do |label, fixture|
             unmarshall_fixture(label, fixture, fixture_kit.model_class)
           end
         documents
       end
 
+      def extract_embedded_attributes(document, attributes)
+        embedded_attrs = {}
+        document.relations.each do |name, relation|
+          macro = macro_from_relation(relation)
+          next unless %i[embeds_one embeds_many].include?(macro)
+          next unless attributes.key?(name)
+          next unless attributes[name].is_a?(Hash) || attributes[name].is_a?(Array)
+
+          embedded_attrs[name] = attributes.delete(name).dup
+        end
+        embedded_attrs
+      end
+
+      def apply_embedded_attributes(document, embedded_attrs)
+        embedded_attrs.each do |name, attrs|
+          relation = document.relations[name]
+          next unless relation
+
+          # Resolve belongs_to fixture references within embedded attrs
+          # before storing, because Mongoid won't resolve them.
+          embedded_class = relation.class_name.constantize
+          macro = macro_from_relation(relation)
+
+          case macro
+          when :embeds_one
+            resolve_embedded_belongs_to(embedded_class, attrs) if attrs.is_a?(Hash)
+          when :embeds_many
+            Array(attrs).each { |item| resolve_embedded_belongs_to(embedded_class, item) if item.is_a?(Hash) }
+          end
+
+          # Use bracket notation to store raw hash data. In Mongoid 8+,
+          # bracket notation doesn't build embedded model objects, but the
+          # data persists correctly. After save + reload, Mongoid hydrates
+          # the embedded documents from the stored hash.
+          document[name] = attrs
+        end
+
+        # Save and reload to hydrate embedded documents from stored hash data.
+        return if embedded_attrs.none?
+
+        save_document(document)
+        document.reload
+      end
+
+      def resolve_embedded_belongs_to(embedded_class, attrs)
+        embedded_class.relations.each do |rel_name, rel|
+          macro = macro_from_relation(rel)
+
+          case macro
+          when :belongs_to
+            next unless attrs.key?(rel_name) && attrs[rel_name].is_a?(String)
+
+            doc = find_or_create_document(rel.class_name, attrs.delete(rel_name))
+            attrs[rel.foreign_key] = doc.id
+          when :embeds_one
+            next unless attrs.key?(rel_name) && attrs[rel_name].is_a?(Hash)
+
+            resolve_embedded_belongs_to(rel.class_name.constantize, attrs[rel_name])
+          when :embeds_many
+            next unless attrs.key?(rel_name) && attrs[rel_name].is_a?(Array)
+
+            attrs[rel_name].each { |item| resolve_embedded_belongs_to(rel.class_name.constantize, item) if item.is_a?(Hash) }
+          end
+        end
+      end
+
       private
 
       def save_document(doc)
-        doc.save({ validate: false })
+        doc.save(validate: false)
       end
 
       def unmarshall_fixture(label, attributes, model_class)
@@ -220,8 +286,6 @@ module Mongoid
             unmarshall_has_many(model_class, attributes, relation)
           when :has_and_belongs_to_many
             unmarshall_has_and_belongs_to_many(model_class, attributes, relation)
-          else
-            # type code here
           end
         end
 
@@ -233,12 +297,7 @@ module Mongoid
         return if value.nil?
 
         if value.is_a?(Hash)
-          if relation.polymorphic?
-            raise(
-              Mongoid::FixtureKit::FixtureError,
-              'Unable to create document from nested attributes in a polymorphic relation'
-            )
-          end
+          raise(Mongoid::FixtureKit::FixtureError, 'Unable to create document from nested attributes in a polymorphic relation') if relation.polymorphic?
 
           document = relation.class_name.constantize.new
           value = unmarshall_fixture(nil, value, relation.class_name)
@@ -247,7 +306,8 @@ module Mongoid
           return
         end
 
-        if relation.polymorphic? && value.sub!(/\s*\(([^)]*)\)\s*/, '')
+        if relation.polymorphic? && value.match?(/\s*\([^)]*\)\s*/)
+          value = value.sub(/\s*\(([^)]*)\)\s*/, '')
           type = Regexp.last_match(1)
           attributes[relation.inverse_type] = type
           attributes[relation.foreign_key] = find_or_create_document(type, value).id

data/lib/mongoid/fixture_kit/version.rb

@@ -1,5 +1,5 @@
 module Mongoid
   class FixtureKit
-    VERSION = '0.3.1'.freeze
+    VERSION = '0.4.0'.freeze
   end
 end

data/lib/mongoid/fixture_kit.rb

@@ -14,6 +14,10 @@ module Mongoid
       @context_class ||= Class.new
     end
 
+    def self.reset_context_class!
+      @context_class = nil
+    end
+
     def initialize(name, class_name, path)
       @name = name
       @path = path
@@ -46,7 +50,9 @@ module Mongoid
       yaml_files = files.push("#{path}.yml")
 
       yaml_files.each_with_object({}) do |file, fixtures|
-        Mongoid::FixtureKit::File.open(file) do |f|
+        next unless ::File.exist?(file)
+
+        Mongoid::FixtureKit::File.parse(file) do |f|
           f.each do |fixture_name, row|
             fixtures[fixture_name] = Mongoid::FixtureKit::Fixture.new(fixture_name, row, model_class)
           end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: mongoid-fixture_kit
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Dániel Sipos
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-01-06 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -46,6 +45,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - LICENSE
+- README.md
 - Rakefile
 - lib/mongoid/fixture_kit.rb
 - lib/mongoid/fixture_kit/class_cache.rb
@@ -65,7 +65,10 @@ licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
-post_install_message:
+  homepage_uri: https://github.com/siposdani87/mongoid-fixture-kit
+  source_code_uri: https://github.com/siposdani87/mongoid-fixture-kit
+  bug_tracker_uri: https://github.com/siposdani87/mongoid-fixture-kit/issues
+  changelog_uri: https://github.com/siposdani87/mongoid-fixture-kit/releases
 rdoc_options: []
 require_paths:
 - lib
@@ -73,15 +76,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Fixtures for Rails Mongoid
 test_files: []