mongoid-fixture_kit 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b8f375c33dca26d8a7405665619d2b3967fcafb8283fa3620218e430ffdbff4c
+  data.tar.gz: 07ea12bbfa497ff03a7adfb138cb844302c3d6147713f7835e61c1ae4e410b7e
+SHA512:
+  metadata.gz: 45eb57698392535c3a60b8a7d0b077945bb5b5e6ebf7808eacfade96f59a50498f5314b9180a38a0dd160891c633c4a60560e5bd697e8f0ebe1fa182eefed4c3
+  data.tar.gz: db7d777fec746e3521631449856d3baaf208cf80849e77f5c82458e5c8def1b9db9f2be8a47001dfc96ccf3893715975230b039a5c2b2f7c786fac30e248d1b8

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 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
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/Rakefile

@@ -0,0 +1,14 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+desc 'Default: run unit tests'
+task :default => :test
+
+desc 'Run tests'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end

data/lib/mongoid/fixture_kit/class_cache.rb

@@ -0,0 +1,25 @@
+module Mongoid
+  class FixtureKit
+    class ClassCache
+      def initialize(class_names)
+        @class_names = class_names.stringify_keys
+        # Remove string values that aren't constants or subclasses of Mongoid::Document
+        @class_names.delete_if { |klass_name, klass| !insert_class(@class_names, klass_name, klass) }
+      end
+
+      def [](fs_name)
+        @class_names.fetch(fs_name) do
+          klass = fs_name.singularize.camelize.safe_constantize
+          insert_class(@class_names, fs_name, klass)
+        end
+      end
+
+      private
+
+      def insert_class(class_names, name, klass)
+        # We only want to deal with Mongoid objects.
+        class_names[name] = (klass if klass && klass < Mongoid::Document)
+      end
+    end
+  end
+end

data/lib/mongoid/fixture_kit/file.rb

@@ -0,0 +1,44 @@
+module Mongoid
+  class FixtureKit
+    class File
+      include Enumerable
+
+      def self.open(file)
+        x = new file
+        block_given? ? yield(x) : x
+      end
+
+      def initialize(file)
+        @file = file
+        @rows = nil
+      end
+
+      def each(&)
+        rows.each(&)
+      end
+
+      private
+
+      def rows
+        return @rows if @rows
+        begin
+          data = YAML.safe_load(render(::File.read(@file)))
+        rescue ArgumentError, Psych::SyntaxError => e
+          raise FormatError, "a YAML error occurred parsing #{@file}. Please note that YAML must be consistently indented using spaces. Tabs are not allowed. Please have a look at http://www.yaml.org/faq.html\nThe exact error was:\n #{e.class}: #{e}", e.backtrace
+        end
+        @rows = data ? validate(data).to_a : []
+      end
+
+      def render(content)
+        context = RenderContext.new
+        ERB.new(content).result(context.binder)
+      end
+
+      def validate(data)
+        raise FormatError, 'fixture is not a hash' unless data.is_a?(Hash) || data.is_a?(YAML::Omap)
+        raise FormatError unless data.all? { |_name, row| row.is_a?(Hash) }
+        data
+      end
+    end
+  end
+end

data/lib/mongoid/fixture_kit/fixture.rb

@@ -0,0 +1,36 @@
+module Mongoid
+  class FixtureKit
+    class Fixture
+      include Enumerable
+
+      attr_reader :name
+      attr_reader :fixture
+      attr_reader :model_class
+
+      def initialize(name, fixture, model_class)
+        @name = name
+        @fixture = fixture
+        @model_class = model_class
+      end
+
+      def class_name
+        model_class&.name
+      end
+
+      def each(&)
+        fixture.each(&)
+      end
+
+      delegate :[], to: :fixture
+
+      alias to_hash fixture
+
+      def find
+        raise FixtureClassNotFound, _('No class attached to find.') unless model_class
+        model_class.unscoped do
+          model_class.find_by('__fixture_name' => name)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/fixture_kit/fixture_class_not_found.rb

@@ -0,0 +1,6 @@
+module Mongoid
+  class FixtureKit
+    class FixtureClassNotFound < FixtureError
+    end
+  end
+end

data/lib/mongoid/fixture_kit/fixture_error.rb

@@ -0,0 +1,6 @@
+module Mongoid
+  class FixtureKit
+    class FixtureError < Mongoid::Errors::MongoidError
+    end
+  end
+end

data/lib/mongoid/fixture_kit/fixture_not_found.rb

@@ -0,0 +1,6 @@
+module Mongoid
+  class FixtureKit
+    class FixtureNotFound < FixtureError
+    end
+  end
+end

data/lib/mongoid/fixture_kit/format_error.rb

@@ -0,0 +1,6 @@
+module Mongoid
+  class FixtureKit
+    class FormatError < FixtureError
+    end
+  end
+end

data/lib/mongoid/fixture_kit/render_context.rb

@@ -0,0 +1,9 @@
+module Mongoid
+  class FixtureKit
+    class RenderContext
+      def binder
+        binding
+      end
+    end
+  end
+end

data/lib/mongoid/fixture_kit/test_helper.rb

@@ -0,0 +1,101 @@
+module Mongoid
+  class FixtureKit
+    module TestHelper
+      extend ActiveSupport::Concern
+
+      def before_setup
+        super
+        setup_fixtures
+      end
+
+      def after_teardown
+        super
+        teardown_fixtures
+      end
+
+      included do
+        # rubocop:disable ThreadSafety/ClassAndModuleAttributes
+        class_attribute :fixture_path
+        class_attribute :fixture_kit_names
+        class_attribute :load_fixtures_once
+        class_attribute :cached_fixtures
+        class_attribute :util
+        # rubocop:enable ThreadSafety/ClassAndModuleAttributes
+
+        self.fixture_path = nil
+        self.fixture_kit_names = [].freeze
+        self.load_fixtures_once = false
+        self.cached_fixtures = nil
+        self.util = Mongoid::FixtureKit::Util.new
+      end
+
+      class_methods do
+        def fixtures(*fixture_kit_names)
+          if fixture_kit_names.first == :all
+            fixture_kit_names = Dir["#{fixture_path}/{**,*}/*.{yml}"]
+            fixture_kit_names.map! { |f| f[(fixture_path.to_s.length + 1)..-5] }
+          else
+            fixture_kit_names = fixture_kit_names.flatten.map(&:to_s)
+          end
+          self.fixture_kit_names |= fixture_kit_names
+          setup_fixture_accessors(fixture_kit_names)
+        end
+
+        def setup_fixture_accessors(fixture_kit_names = nil)
+          fixture_kit_names = Array(fixture_kit_names || self.fixture_kit_names)
+          methods = Module.new do
+            fixture_kit_names.each do |fs_name|
+              fs_name = fs_name.to_s
+              accessor_name = fs_name.tr('/', '_').to_sym
+              define_method(accessor_name) do |*fixture_names|
+                force_reload = false
+                force_reload = fixture_names.pop if fixture_names.last == true || fixture_names.last == :reload
+                @fixture_cache[fs_name] ||= {}
+                instances = fixture_names.map do |f_name|
+                  f_name = f_name.to_s
+                  @fixture_cache[fs_name].delete(f_name) if force_reload
+                  raise FixtureNotFound, "No fixture named '#{f_name}' found for fixture set '#{fs_name}'" unless @loaded_fixtures[fs_name] && @loaded_fixtures[fs_name][f_name]
+                  @fixture_cache[fs_name][f_name] ||= @loaded_fixtures[fs_name][f_name].find
+                end
+                instances.length == 1 ? instances.first : instances
+              end
+            end
+          end
+          include methods
+        end
+      end
+
+      def setup_fixtures
+        @fixture_cache = {}
+
+        if self.class.cached_fixtures && self.class.load_fixtures_once
+          self.class.fixtures(self.class.fixture_kit_names)
+          @loaded_fixtures = self.class.cached_fixtures
+        else
+          self.class.util.reset_cache
+          self.loaded_fixtures = load_fixtures
+          self.class.cached_fixtures = @loaded_fixtures
+        end
+      end
+
+      def teardown_fixtures
+        self.class.util.reset_cache
+      end
+
+      private
+
+      def load_fixtures
+        fixture_kit_names = self.class.fixture_kit_names
+        if fixture_kit_names.empty?
+          self.class.fixtures(:all)
+          fixture_kit_names = self.class.fixture_kit_names
+        end
+        self.class.util.create_fixtures(self.class.fixture_path, fixture_kit_names)
+      end
+
+      def loaded_fixtures=(fixtures)
+        @loaded_fixtures = fixtures.dup.index_by(&:name)
+      end
+    end
+  end
+end

data/lib/mongoid/fixture_kit/util.rb

@@ -0,0 +1,285 @@
+module Mongoid
+  class FixtureKit
+    class Util
+      def initialize
+        @cached_fixtures = {}
+        @all_loaded_fixtures = {}
+      end
+
+      def cached_fixtures(keys_to_fetch = nil)
+        if keys_to_fetch
+          @cached_fixtures.values_at(*keys_to_fetch)
+        else
+          @cached_fixtures.values
+        end
+      end
+
+      def reset_cache
+        @cached_fixtures.clear
+      end
+
+      def fixture_is_cached?(name)
+        @cached_fixtures[name]
+      end
+
+      def cache_fixtures(fixtures_map)
+        @cached_fixtures.update(fixtures_map)
+      end
+
+      def update_all_loaded_fixtures(fixtures_map)
+        @all_loaded_fixtures = fixtures_map
+      end
+
+      def create_fixtures(fixtures_directory, fixture_kit_names, class_names = {})
+        fixture_kit_names = Array(fixture_kit_names).map(&:to_s)
+        class_names = Mongoid::FixtureKit::ClassCache.new(class_names)
+
+        files_to_read = fixture_kit_names.reject do |fs_name|
+          fixture_is_cached?(fs_name)
+        end
+
+        return cached_fixtures(fixture_kit_names) if files_to_read.empty?
+
+        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))
+        end
+
+        update_all_loaded_fixtures(fixtures_map)
+
+        fixture_kits.each do |fixture_kit|
+          collection_documents(fixture_kit).each do |model, documents|
+            model = class_names[model]
+            next unless model
+            documents.each do |attributes|
+              create_or_update_document(model, attributes)
+            end
+          end
+        end
+
+        cache_fixtures(fixtures_map)
+        cached_fixtures(fixture_kit_names)
+      end
+
+      def create_or_update_document(model, attributes)
+        model = model.constantize if model.is_a? String
+
+        document = find_or_create_document(model, attributes['__fixture_name'])
+        update_document(document, attributes)
+      end
+
+      def update_document(document, attributes)
+        attributes.delete('_id') if document.attributes.key?('_id')
+
+        keys = (attributes.keys + document.attributes.keys).uniq
+        keys.each do |key|
+          value = attributes[key] || document[key]
+          if key.include?('_translations')
+            document.public_send("#{key}=", value)
+          else
+            document[key] = value
+          end
+        end
+
+        sanitize_new_embedded_documents(document)
+        save_document(document)
+        document
+      end
+
+      def sanitize_new_embedded_documents(document, is_new: false)
+        document.relations.each do |name, relation|
+          case macro_from_relation(relation)
+          when :embeds_one
+            embedded_document_set_default_values(document.public_send(relation.name), document[name]) if (document.changes[name] && !document.changes[name][1].nil?) || (is_new && document[name])
+          when :embeds_many
+            if (document.changes[name] && !document.changes[name][1].nil?) || (is_new && document[name])
+              embedded_documents = document.public_send(relation.name)
+              embedded_documents.each_with_index do |embedded, i|
+                embedded_document_set_default_values(embedded, document[name][i])
+              end
+            end
+          when :belongs_to
+            if is_new && document.attributes[name]
+              value = document.attributes.delete(name)
+              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
+
+      def embedded_document_set_default_values(document, attributes)
+        sanitize_new_embedded_documents(document, is_new: true)
+        attributes.delete('_id')
+        document.fields.select do |k, v|
+          k != '_id' && !v.default_val.nil? && attributes[k] == document[k]
+        end
+      end
+
+      def find_or_create_document(model, fixture_name)
+        model = model.constantize if model.is_a? String
+
+        document = model.where('__fixture_name' => fixture_name).first
+        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
+        end
+        document
+      end
+
+      def macro_from_relation(relation)
+        return relation.macro if defined?(Mongoid::Relations) && relation.instance_of?(Mongoid::Relations::Metadata)
+        relation.class.name.split('::').last.underscore.to_sym
+      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 = {}
+        documents[fixture_kit.class_name] = fixture_kit.fixtures.map do |label, fixture|
+          unmarshall_fixture(label, fixture, fixture_kit.model_class)
+        end
+        documents
+      end
+
+      private
+
+      def save_document(doc)
+        doc.save({ validate: false })
+      end
+
+      def unmarshall_fixture(label, attributes, model_class)
+        model_class = model_class.constantize if model_class.is_a? String
+        attributes = attributes.to_hash
+
+        if label
+          attributes['__fixture_name'] = label
+
+          # interpolate the fixture label
+          attributes.each do |key, value|
+            attributes[key] = value.gsub('$LABEL', label) if value.is_a?(String)
+          end
+        end
+
+        return attributes if model_class.nil?
+
+        unless attributes.key?('_id')
+          document = if label
+                       find_or_create_document(model_class, label)
+                     else
+                       model_class.new
+                     end
+          attributes['_id'] = document.id
+        end
+
+        set_attributes_timestamps(model_class, attributes)
+
+        model_class.relations.each_value do |relation|
+          case macro_from_relation(relation)
+          when :belongs_to
+            unmarshall_belongs_to(model_class, attributes, relation)
+          when :has_many
+            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
+
+        attributes
+      end
+
+      def unmarshall_belongs_to(_model_class, attributes, relation)
+        value = attributes.delete(relation.name.to_s)
+        return if value.nil?
+
+        if value.is_a? Hash
+          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)
+          document = update_document(document, value)
+          attributes[relation.foreign_key] = document.id
+          return
+        end
+
+        if relation.polymorphic? && 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
+        else
+          attributes[relation.foreign_key] = find_or_create_document(relation.class_name, value).id
+        end
+      end
+
+      def unmarshall_has_many(model_class, attributes, relation)
+        values = attributes.delete(relation.name.to_s)
+        return if values.nil?
+
+        values.each do |value|
+          if value.is_a? Hash
+            document = relation.class_name.constantize.new
+            value[relation.foreign_key] = attributes['_id']
+            value[relation.type] = model_class.name if relation.polymorphic?
+            value = unmarshall_fixture(nil, value, relation.class_name)
+            update_document(document, value)
+            next
+          end
+
+          document = find_or_create_document(relation.class_name, value)
+          if relation.polymorphic?
+            update_document(document, { relation.foreign_key => attributes['_id'], relation.type => model_class.name })
+          else
+            update_document(document, { relation.foreign_key => attributes['_id'] })
+          end
+        end
+      end
+
+      def unmarshall_has_and_belongs_to_many(_model_class, attributes, relation)
+        values = attributes.delete(relation.name.to_s)
+        return if values.nil?
+
+        key = relation.foreign_key
+        attributes[key] = []
+
+        values.each do |value|
+          if value.is_a? Hash
+            document = relation.class_name.constantize.new
+            value[relation.inverse_foreign_key] = Array(attributes['_id'])
+            value = unmarshall_fixture(nil, value, relation.class_name)
+            update_document(document, value)
+            attributes[key] << document.id
+            next
+          end
+
+          document = find_or_create_document(relation.class_name, value)
+          attributes[key] << document.id
+
+          update_document(document, { relation.inverse_foreign_key => Array(attributes['_id']) })
+        end
+      end
+
+      def set_attributes_timestamps(model_class, attributes)
+        now = Time.now.utc
+
+        attributes['c_at'] = now if model_class < Mongoid::Timestamps::Created::Short && !attributes.key?('c_at')
+        attributes['created_at'] = now if model_class < Mongoid::Timestamps::Created && !attributes.key?('created_at')
+
+        attributes['u_at'] = now if model_class < Mongoid::Timestamps::Updated::Short && !attributes.key?('u_at')
+        attributes['updated_at'] = now if model_class < Mongoid::Timestamps::Updated && !attributes.key?('updated_at')
+      end
+    end
+  end
+end

data/lib/mongoid/fixture_kit/version.rb

@@ -0,0 +1,5 @@
+module Mongoid
+    class FixtureKit
+      VERSION = '0.1.0'
+    end
+end

data/lib/mongoid/fixture_kit.rb

@@ -0,0 +1,47 @@
+module Mongoid
+  class FixtureKit
+    attr_reader :name
+    attr_reader :path
+    attr_reader :model_class
+    attr_reader :class_name
+    attr_reader :fixtures
+
+    def initialize(name, class_name, path)
+      @name = name
+      @path = path
+
+      if class_name.is_a?(Class)
+        @model_class = class_name
+      elsif class_name
+        @model_class = class_name.safe_constantize
+      end
+
+      @class_name = if @model_class.respond_to?(:name)
+                      @model_class.name
+                    else
+                      name.singularize.camelize
+                    end
+
+      @fixtures = read_fixture_files
+    end
+
+    delegate :[], to: :fixtures
+
+    private
+
+    def read_fixture_files
+      files = Dir["#{path}/{**,*}/*.yml"].select do |f|
+        ::File.file?(f)
+      end
+      yaml_files = files.push("#{path}.yml")
+
+      yaml_files.each_with_object({}) do |file, fixtures|
+        Mongoid::FixtureKit::File.open(file) do |f|
+          f.each do |fixture_name, row|
+            fixtures[fixture_name] = Mongoid::FixtureKit::Fixture.new(fixture_name, row, model_class)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid-fixture_kit.rb

@@ -0,0 +1,7 @@
+require 'mongoid/fixture_kit'
+
+module Mongoid
+  module Document
+    attr_accessor :__fixture_name
+  end
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: mongoid-fixture_kit
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dániel Sipos
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-02-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+description: Use fixtures with Mongoid the same way you did with ActiveRecord
+email:
+- siposdani87@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- Rakefile
+- lib/mongoid-fixture_kit.rb
+- lib/mongoid/fixture_kit.rb
+- lib/mongoid/fixture_kit/class_cache.rb
+- lib/mongoid/fixture_kit/file.rb
+- lib/mongoid/fixture_kit/fixture.rb
+- lib/mongoid/fixture_kit/fixture_class_not_found.rb
+- lib/mongoid/fixture_kit/fixture_error.rb
+- lib/mongoid/fixture_kit/fixture_not_found.rb
+- lib/mongoid/fixture_kit/format_error.rb
+- lib/mongoid/fixture_kit/render_context.rb
+- lib/mongoid/fixture_kit/test_helper.rb
+- lib/mongoid/fixture_kit/util.rb
+- lib/mongoid/fixture_kit/version.rb
+homepage: https://github.com/siposdani87/mongoid-fixture-kit
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.26
+signing_key:
+specification_version: 4
+summary: Fixtures for Rails Mongoid
+test_files: []