fixture_record 0.1.0.pre.rc

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f064d7bf54652f52a22d8cd269857e20a5b1478d62e56bfc9caf8b49b9835bfe
+  data.tar.gz: 169cec159195200f218601686768081c1f8097f2a29bb84ccc39a69d08fb93a1
+SHA512:
+  metadata.gz: 5829f715c8d443a626cb5752b5f269ef6d8effbc2e8f34af7dcdcb847d9aac419876a282610802d8fb8ed9b25b4a63d3264bb8dbf717ee5c03451692663d6dfd
+  data.tar.gz: 85fa9ff11cf929a973ad4aa1b575003e2832d1bf1cbe49676eafee9753d05c86664907d1733b914caefd9ef7dc76ae2282b348036301be541fe5c6076a8da831

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright Brad Schrag
+
+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/README.md

@@ -0,0 +1,138 @@
+# FixtureRecord
+When it comes to testing, ActiveRecrod::Fixtures provide a huge performance benefit over FactoryBot but at the expense of setting up the necessary test data. For complex associations and relationships, a large amount of time might be spent simply trying to setup the data. FixtureRecord provides a `to_test_fixture` method that accepts a chain of associations as an argument that allows you to quickly turn a large collection of existing records into test fixtures.
+
+## Usage
+`to_test_fixture` is a method that will turn the record into a test fixture. By default, the name of the fixture record will be `param_key` of the record's class and the record's id joined with `_`.
+
+```ruby
+user = User.find(1)
+user.to_test_fixture
+
+# creates test/fixtures/users.yml if it does not exists
+```
+```yaml
+# users.yml
+
+user_1:
+  email: the-user-email@domain.com
+  first_name: Foo
+  last_name: Bar
+```
+
+### Associations
+Let's take a basic Blog app with the classes User, Post, and Comment:
+```ruby
+class User
+  has_many :posts, foreign_key: :author_id
+  has_many :comments
+end
+
+class Post
+  has_many :comments
+  belongs_to :author, class_name: 'User'
+end
+
+class Comment
+  belongs_to :commentable, polymorphic: true
+  belongs_to :user
+end
+```
+Let's say an edge case bug has been found with a particular post and it's related comments. To write the test, you need the post record, its authors, the comments, and the user for each of the comments to properly replicate the edge case.
+
+```ruby
+edge_case_post = Post.find ...
+edge_case_post.to_test_fixture(:author, comments: :user)
+```
+This would create a test fixture for the post, its author, all the comments on the post and their respective users. This will also change the `belongs_to` relationships in the yaml files to reflect their respective fixture counterparts. For example, if `Post#12` author is `User#49`,
+and the post has `Comment#27` the fixture records might look like:
+```yaml
+# users.yml
+
+user_49:
+  email: user-49@tester.com
+  ...
+
+# posts.yml
+post_12:
+  author: user_49
+  ...
+
+# comments.yml
+comment_27:
+  user: user_1
+  commentable: post_12 (Post)
+```
+
+Note that these changes to the `belongs_to` associations is only applicable to records that are part of the associations that are being passed into `to_test_fixture`. So taking the same example as above, `edge_case_post.to_test_fixture` would yield the following:
+```yaml
+post_12:
+  author_id: 49
+```
+
+Currently, `FixtureRecord` will also not attempt to already existing fixtures to newly created data.
+```ruby
+User.find(49).to_test_fixture
+Post.find(12).to_test_fixture
+```
+The above would yield fixtures that are not associated to one another.
+```yaml
+# users.yml
+user_49:
+  ...
+
+
+# posts.yml
+post_12:
+  author_id: 49
+```
+
+### FixtureRecord::Naming
+There might be instances where a record was used for a particular test fixture and you want to use this same record again for a different test case but want to keep the data isolated. `FixtureRecord::Naming` (automatically included with FixtureRecord) provides`fixture_record_prefix` and `fixture_record_suffix`. These values are propagated to the associated records when calling `to_test_fixture`.
+```ruby
+user.test_fixture_prefix = :foo
+user.to_test_fixture(:posts)
+
+# users.yml
+
+foo_user_12:
+  ...
+
+
+# posts.yml
+
+foo_post_49:
+  author: foo_user_12
+  ...
+```
+
+## Installation
+`FixtureRecord` is only needed as a development dependency.
+```ruby
+bundle add fixture_record --group development
+```
+
+Or add directly to your Gemfile:
+```ruby
+# Gemfile
+
+group :development do
+  ...
+  gem 'fixture_record'
+end
+```
+
+And then execute:
+```bash
+$ bundle install
+```
+
+Finally, run the installer:
+```bash
+$ rails g fixture_record:install
+```
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,3 @@
+require "bundler/setup"
+
+require "bundler/gem_tasks"

data/lib/fixture_record/association_traversal.rb

@@ -0,0 +1,79 @@
+module FixtureRecord
+  module AssociationTraversal
+    class UnrecognizedAssociationError < StandardError; end
+
+    def traverse_fixture_record_associations(*associations)
+      associations.each do |association|
+        Builder.new(self, association).build
+      end
+    end
+
+    class Builder
+      def initialize(source_record, association)
+        @source_record = source_record
+        @association = association
+      end
+
+      def build
+        case @association
+        when Array then ArrayBuilder.new(@source_record, @association).build
+        when Hash then HashBuilder.new(@source_record, @association).build
+        when Symbol then SymbolBuilder.new(@source_record, @association).build
+        else raise UnrecognizedAssociationTypeError.new(
+          "Unrecognized association type of #{@association.class}. Valid types are Hash, Array, or Symbol"
+        )
+        end
+      end
+    end
+
+    class SymbolBuilder
+      def initialize(source_record, symbol, *next_associations)
+        @source_record = source_record
+        @symbol = symbol
+        @next_associations = next_associations
+      end
+
+      def build
+        raise UnrecognizedAssociationError.new(
+          "#{@symbol} is not a recognized association or method on #{@source_record.class}. Is it misspelled?"
+        ) unless @source_record.respond_to?(@symbol)
+
+        built_records = Array.wrap(@source_record.send(@symbol)).compact_blank
+        return unless built_records.present?
+
+        built_records.each do |record|
+          record.fixture_record_prefix = @source_record.fixture_record_prefix
+          record.fixture_record_suffix = @source_record.fixture_record_suffix
+          record.to_test_fixture(*@next_associations)
+        end
+      end
+
+    end
+
+    class HashBuilder
+      def initialize(source_record, hash)
+        @source_record = source_record
+        @hash = hash
+      end
+
+      def build
+        @hash.each do |symbol, next_associations|
+          SymbolBuilder.new(@source_record, symbol, *next_associations).build
+        end
+      end
+    end
+
+    class ArrayBuilder
+      def initialize(source_record, array)
+        @source_record = source_record
+        @array = array
+      end
+
+      def build
+        @array.each do |entry|
+          Builder.new(@source_record, entry).build
+        end
+      end
+    end
+  end
+end

data/lib/fixture_record/belongs_to_updation.rb

@@ -0,0 +1,23 @@
+module FixtureRecord
+  module BelongsToUpdation
+    extend ActiveSupport::Concern
+
+    def update_belongs_to_test_fixture_associations
+      self.class.reflect_on_all_associations(:belongs_to).each do |assoc|
+        klass_name = assoc.options[:polymorphic] ? send(assoc.foreign_type) : assoc.class_name
+        next unless klass_name.nil? || FixtureRecord.cache.contains_class?(klass_name)
+
+        belongs_to = send(assoc.name)
+        if FixtureRecord.cache.contains_record? belongs_to
+          _fixture_record_attributes.delete assoc.foreign_key
+          foreign_key_value = belongs_to.test_fixture_name
+          if assoc.options[:polymorphic]
+            _fixture_record_attributes.delete assoc.foreign_type
+            foreign_key_value = "#{foreign_key_value} (#{belongs_to.class})"
+          end
+          _fixture_record_attributes[assoc.name.to_s] = foreign_key_value
+        end
+      end
+    end
+  end
+end

data/lib/fixture_record/cache.rb

@@ -0,0 +1,32 @@
+module FixtureRecord
+  class Cache < Hash
+
+    def dump!
+      prepare!
+      merge_data!
+      FixtureRecord.data.write!
+    end
+
+    def contains_class?(klass_or_string)
+      klass = klass_or_string.is_a?(String) ? klass_or_string.constantize : klass_or_string
+      values.map(&:class).include?(klass)
+    end
+
+    def contains_record?(record)
+      invert.key? record
+    end
+
+    def merge_data!
+      self.each do |fixture_id, record|
+        FixtureRecord.data.merge_record(record)
+      end
+    end
+
+    def prepare!
+      self.values
+        .each(&:filter_attributes_for_test_fixture)
+        .each(&:sanitize_attributes_for_test_fixture)
+        .each(&:update_belongs_to_test_fixture_associations)
+    end
+  end
+end

data/lib/fixture_record/data.rb

@@ -0,0 +1,32 @@
+class FixtureRecord::Data < Hash
+
+  def initialize(...)
+    super(...)
+    self.default_proc = Proc.new { |hash, klass| hash[klass] = load_fixture_for(klass) }
+  end
+
+  def load_fixture_for(klass)
+    if File.exist?(fixture_path_for(klass))
+      YAML.load_file(fixture_path_for(klass))
+    else
+      {}
+    end
+  end
+
+  def write!
+    FileUtils.mkdir_p(Rails.root.join('test/fixtures'))
+    self.each do |klass, data|
+      File.open(fixture_path_for(klass), 'w') { |f| f.write data.to_yaml }
+    end
+  end
+
+  def fixture_path_for(klass)
+    Rails.root.join('test/fixtures', klass.table_name + '.yml')
+  end
+
+  def merge_record(record)
+    key = record.test_fixture_name
+
+    self[record.class].merge!(key => record._fixture_record_attributes) unless self[record.class].key?(key)
+  end
+end

data/lib/fixture_record/filterable_attributes.rb

@@ -0,0 +1,30 @@
+module FixtureRecord
+  module FilterableAttributes
+    def filter_attributes_for_test_fixture
+      self._fixture_record_attributes = FilteredAttributes.new(self).cast
+    end
+
+    class FilteredAttributes
+      attr_reader :record
+      def initialize(record)
+        @record = record
+      end
+
+      def db_columns
+        record.class.columns.map(&:name)
+      end
+
+      def excluded_columns
+        %w( id )
+      end
+
+      def applicable_columns
+        db_columns - excluded_columns
+      end
+
+      def cast
+        record.attributes.slice(*applicable_columns)
+      end
+    end
+  end
+end

data/lib/fixture_record/naming.rb

@@ -0,0 +1,10 @@
+module FixtureRecord
+  module Naming
+    attr_accessor :fixture_record_prefix
+    attr_accessor :fixture_record_suffix
+
+    def test_fixture_name
+      [fixture_record_prefix, self.class.model_name.param_key, (self.id || 'new'), fixture_record_suffix].compact_blank.join '_'
+    end
+  end
+end

data/lib/fixture_record/railtie.rb

@@ -0,0 +1,7 @@
+module FixtureRecord
+  class Railtie < ::Rails::Railtie
+    # generators do
+    #   require "lib/fixture_record/generators/install"
+    # end
+  end
+end

data/lib/fixture_record/sanitizable.rb

@@ -0,0 +1,47 @@
+module FixtureRecord::Sanitizable
+  extend ActiveSupport::Concern
+
+  class_methods do
+  end
+
+  def sanitize_attributes_for_test_fixture
+    _fixture_record_attributes.each do |attr, value|
+      registry_key = [self.class.name, attr.to_s].join('.')
+      _fixture_record_attributes[attr] = sanitize_value_for_test_fixture(registry_key, value)
+    end
+  end
+
+  def sanitize_value_for_test_fixture(registry_key, value)
+    FixtureRecord.registry.fetch(registry_key).inject(value) do |agg, sanitizer|
+      agg = sanitizer.cast(agg)
+    end
+  end
+
+  class Base
+    def cast(value)
+      raise NotImplementedError.new "#cast must be defined in #{self.class.name} and it is not"
+    end
+  end
+
+  class Registry
+    @_fixture_record_sanitizer_pattern_registry = {}
+    @_fixture_record_sanitizer_name_registry = {}
+
+    def self.register_sanitizer(klass, *patterns, as: nil)
+      if as
+        @_fixture_record_sanitizer_name_registry[as.to_sym] = klass.new
+      end
+      patterns.each do |pattern|
+        @_fixture_record_sanitizer_pattern_registry[pattern] = klass.new
+      end
+    end
+
+    def self.fetch(to_be_matched)
+      if @_fixture_record_sanitizer_name_registry.key?(to_be_matched)
+        @_fixture_record_sanitizer_name_registry[to_be_matched]
+      else
+        @_fixture_record_sanitizer_pattern_registry.select { |pattern, value| to_be_matched.match(pattern) }.values
+      end
+    end
+  end
+end

data/lib/fixture_record/sanitizers/simple_timestamp.rb

@@ -0,0 +1,11 @@
+module FixtureRecord
+  module Sanitizers
+    class SimpleTimestamp < FixtureRecord::Sanitizer
+      def cast(value)
+        value.to_s
+      end
+    end
+    FixtureRecord.registry.register_sanitizer(FixtureRecord::Sanitizers::SimpleTimestamp, /created_at$|updated_at$/, as: :simple_timestamp)
+  end
+end
+

data/lib/fixture_record/version.rb

@@ -0,0 +1,3 @@
+module FixtureRecord
+  VERSION = "0.1.0-rc"
+end

data/lib/fixture_record.rb

@@ -0,0 +1,69 @@
+require "fixture_record/version"
+require "fixture_record/railtie"
+require "fixture_record/cache"
+require "fixture_record/data"
+require "fixture_record/naming"
+require "fixture_record/association_traversal"
+require "fixture_record/filterable_attributes"
+require "fixture_record/belongs_to_updation"
+require "fixture_record/sanitizable"
+
+module FixtureRecord
+  extend ActiveSupport::Concern
+  mattr_accessor :_locked_by, :cache, :data
+
+  included do
+    attr_accessor :_fixture_record_attributes
+  end
+
+  include FixtureRecord::Naming
+  include FixtureRecord::AssociationTraversal
+  include FixtureRecord::FilterableAttributes
+  include FixtureRecord::Sanitizable
+  include FixtureRecord::BelongsToUpdation
+
+  Sanitizer = FixtureRecord::Sanitizable::Base
+
+  def to_test_fixture(*associations)
+    FixtureRecord.lock!(self)
+    FixtureRecord.cache[self.test_fixture_name] ||= self
+    traverse_fixture_record_associations(*associations)
+    FixtureRecord.cache.dump! if  FixtureRecord.locked_by?(self)
+  ensure
+    FixtureRecord.release!(self)
+  end
+
+  class << self
+    def lock!(owner)
+      return if locked?
+
+      @@_locked_by = owner
+      @@cache = FixtureRecord::Cache.new
+      @@data = FixtureRecord::Data.new
+    end
+
+    def locked?
+      @@_locked_by.present?
+    end
+
+    def release!(owner)
+      if locked_by?(owner)
+        @@_locked_by = nil
+        @@_cache = nil
+        true
+      else
+        false
+      end
+    end
+
+    def locked_by?(owner)
+      @@_locked_by == owner
+    end
+
+    def registry
+      FixtureRecord::Sanitizable::Registry
+    end
+  end
+end
+
+require "fixture_record/sanitizers/simple_timestamp"

data/lib/generators/fixture_record/install/USAGE.md

@@ -0,0 +1,8 @@
+Description:
+  Installs FxitureRecord
+
+Example:
+  rails generate fixture_record:install
+
+This will create:
+  config/initializers/fixture_record.rb

data/lib/generators/fixture_record/install/install_generator.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module FixtureRecord::Generators
+	class InstallGenerator < ::Rails::Generators::Base
+    source_root File.expand_path("templates", __dir__)
+
+    def create_fixture_record_schema
+      # TODO - implement the generator
+    end
+
+    def create_initializer
+			template "initializer.rb", Rails.root.join("config/initializers/fixture_record.rb")
+		end
+  end
+end

data/lib/generators/fixture_record/install/templates/initializer.rb

@@ -0,0 +1,9 @@
+# FixtureRecord is currently only intended to be loaded in a development environment.
+# Change this conditional at your own risk if you want it to load in production.
+
+if Rails.env.development?
+  # Inject FixtureRecord after active_record loads
+  ActiveSupport.on_load(:active_record) do
+    ActiveRecord::Base.include(FixtureRecord)
+  end
+end

data/lib/tasks/fixture_record_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :fixture_record do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: fixture_record
+version: !ruby/object:Gem::Version
+  version: 0.1.0.pre.rc
+platform: ruby
+authors:
+- Brad Schrag
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2024-03-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6'
+description: Helper library for generating test fixtures for existing records and
+  their associated associations and relationships.
+email:
+- brad.schrag@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/fixture_record.rb
+- lib/fixture_record/association_traversal.rb
+- lib/fixture_record/belongs_to_updation.rb
+- lib/fixture_record/cache.rb
+- lib/fixture_record/data.rb
+- lib/fixture_record/filterable_attributes.rb
+- lib/fixture_record/naming.rb
+- lib/fixture_record/railtie.rb
+- lib/fixture_record/sanitizable.rb
+- lib/fixture_record/sanitizers/simple_timestamp.rb
+- lib/fixture_record/version.rb
+- lib/generators/fixture_record/install/USAGE.md
+- lib/generators/fixture_record/install/install_generator.rb
+- lib/generators/fixture_record/install/templates/initializer.rb
+- lib/tasks/fixture_record_tasks.rake
+homepage: https://github.com/bschrag620/fixture_record
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/bschrag620/fixture_record
+  source_code_uri: https://github.com/bschrag620/fixture_record
+  changelog_uri: https://github.com/bschrag620/fixture_record
+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.5.6
+signing_key: 
+specification_version: 4
+summary: Helper library for generating test fixtures.
+test_files: []