fixture_bot 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 882daa77b1a9840f2179c979b5bd51e09782e7ef011d28dc761bbbdd65789942
+  data.tar.gz: 0c8957cc5ff3f0c412ae7e9d85acc41baf407b7090de7f2e55450e77573ae13e
+SHA512:
+  metadata.gz: e4c795d92c941773f0af08ffa32d289a0d6b7ae2421cfc3cb6934f2c94724d53c64078d0b179e25761ec534a8a5a96b67333146eb4bdbb0ee926a0a6ba2a85ec
+  data.tar.gz: 9869573d964e08fb7f7632f3a624688f48a066f325a87baa51ab789120cc286d8f165001f0954817aeaf4151aaec6e803c1e7247b288dbc13824a103fb94fb6b

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,24 @@
+inherit_gem:
+  rubocop-gp:
+    - .rubocop.yml
+
+AllCops:
+  TargetRubyVersion: 3.1
+
+Lint/ConstantDefinitionInBlock:
+  Enabled: false
+
+RSpec/LeakyConstantDeclaration:
+  Enabled: false
+
+Rails/ApplicationRecord:
+  Enabled: false
+
+Rails/TimeZone:
+  Enabled: false
+
+Layout/EmptyLinesAroundModuleBody:
+  EnforcedStyle: no_empty_lines
+
+Layout/EmptyLinesAroundClassBody:
+  EnforcedStyle: no_empty_lines

data/Gemfile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+gemspec
+
+gem "bundler"
+gem "minitest-utils"
+gem "rails"
+gem "rake"
+gem "rspec-rails"
+gem "rubocop-gp", github: "corp-gp/rubocop-gp"
+gem "simplecov"
+gem "sqlite3", "~> 1.4"

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Ermolaev Andrey
+
+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,230 @@
+# factory_bot-preload
+
+[![Travis-CI](https://travis-ci.org/fnando/factory_bot-preload.svg)](https://travis-ci.org/fnando/factory_bot-preload)
+[![Code Climate](https://codeclimate.com/github/fnando/factory_bot-preload/badges/gpa.svg)](https://codeclimate.com/github/fnando/factory_bot-preload)
+[![Test Coverage](https://codeclimate.com/github/fnando/factory_bot-preload/badges/coverage.svg)](https://codeclimate.com/github/fnando/factory_bot-preload/coverage)
+[![Gem](https://img.shields.io/gem/v/factory_bot-preload.svg)](https://rubygems.org/gems/factory_bot-preload)
+[![Gem](https://img.shields.io/gem/dt/factory_bot-preload.svg)](https://rubygems.org/gems/factory_bot-preload)
+
+We all love Rails fixtures because they're fast, but we hate to deal with YAML/CSV/SQL files. Here enters [factory_bot](https://rubygems.org/gems/factory_bot) (FB).
+
+Now, you can easily create records by using predefined factories. The problem is that hitting the database everytime to create records is pretty slow. And believe me, you'll feel the pain when you have lots of tests/specs.
+
+So here enters Factory Bot Preload (FBP). You can define which factories will be preloaded, so you don't have to recreate it every time (that will work for 99.37% of the time, according to statistics I just made up).
+
+### Installation
+
+Add both FB and FBP to your Gemfile:
+
+```ruby
+source "https://rubygems.org"
+
+gem "rails"
+
+group :test, :development do
+  gem "factory_bot"
+  gem "fixture_bot", require: false
+end
+```
+
+Notice that adding `require: false` is important; otherwise you won't be able to
+run commands such as `rails db:test:prepare`.
+
+### RSpec Setup
+
+On your `spec/spec_helper.rb` file, make sure that transactional fixtures are
+enabled. Here's is my file without all those RSpec comments:
+
+```ruby
+ENV["RAILS_ENV"] ||= "test"
+require File.expand_path("../../config/environment", __FILE__)
+require "rspec/rails"
+
+# First, load fixture_bot/preload.
+require "fixture_bot/preload"
+
+# Then load your factories
+Dir[Rails.root.join("spec/support/factories/**/*.rb")].each do |file|
+  require file
+end
+
+RSpec.configure do |config|
+  config.use_transactional_fixtures = true
+  config.mock_with :rspec
+end
+```
+
+### Minitest Setup
+
+On your `test/test_helper.rb` file, make sure that transaction fixtures are
+enabled. Here's what your file may look like:
+
+```ruby
+ENV["RAILS_ENV"] ||= "test"
+require_relative "../config/environment"
+require "rails/test_help"
+
+module ActiveSupport
+  class TestCase
+    self.use_instantiated_fixtures = true
+  end
+end
+
+# First, load fixture_bot/preload.
+require "fixture_bot/preload"
+
+# Then load your factories.
+Dir["./test/support/factories/**/*.rb"].each do |file|
+  require file
+end
+
+# Finally, setup minitest.
+# Your factories won't behave correctly unless you
+# call `FixtureBot.minitest` after loading them.
+FixtureBot.minitest
+```
+
+### Usage
+
+Create your factories and load it from your setup file (either
+`test/test_helper.rb` or `spec/spec_helper.rb`) You may have something like
+this:
+
+```ruby
+FactoryBot.define do
+  factory :user do
+    name "John Doe"
+    sequence(:email) {|n| "john#{n}@example.org" }
+    sequence(:username) {|n| "john#{n}" }
+    password "test"
+    password_confirmation "test"
+  end
+
+  factory :projects do
+    name "My Project"
+    association :user
+  end
+end
+```
+
+To define your preloadable factories, just use the `preload` method:
+
+```ruby
+FactoryBot.define do
+  factory :user do
+    name "John Doe"
+    sequence(:email) {|n| "john#{n}@example.org" }
+    sequence(:username) {|n| "john#{n}" }
+    password "test"
+    password_confirmation "test"
+  end
+
+  factory :projects do
+    name "My Project"
+    association :user
+  end
+
+  preload do
+    fixture(:john) { create(:user) }
+    fixture(:myapp) { create(:project, user: users(:john)) }
+  end
+end
+```
+
+You can also use preloaded factories on factory definitions.
+
+```ruby
+FactoryBot.define do
+  factory :user do
+    # ...
+  end
+
+  factory :projects do
+    name "My Project"
+    user { users(:john) }
+  end
+
+  preload do
+    fixture(:john) { create(:user) }
+    fixture(:myapp) { create(:project, user: users(:john)) }
+  end
+end
+```
+
+
+If you need to create records with specifying id, use `fixture_stub_const`, it stub const in model to next value from generated primary key
+
+```ruby
+class User
+  ADMIN_ID = 10
+
+  def can_edit_article?
+    id == ADMIN_ID
+  end
+end
+```
+
+```ruby
+FactoryBot.define do
+  factory :user do
+    # ...
+  end
+
+  preload do
+    fixture(:john) { create(:user) }
+    fixture_stub_const(:admin, :ADMIN_ID) { create(:user) }
+  end
+end
+```
+
+```ruby
+describe User do
+  let(:admin) { users(:admin) }
+
+  it "admin can edit article" do
+    expect(admin).to be_can_edit_article
+  end
+end
+````
+
+
+Like Rails fixtures, FBP will define methods for each model. You can use it on
+your examples and alike.
+
+```ruby
+require "test_helper"
+
+class UserTest < ActiveSupport::TestCase
+  test "returns john's record" do
+    assert_instance_of User, users(:john)
+  end
+
+  test "returns myapp's record" do
+    assert_equal users(:john), projects(:myapp).user
+  end
+end
+```
+
+Or if you're using RSpec:
+
+```ruby
+require "spec_helper"
+
+describe User do
+  let(:user) { users(:john) }
+
+  it "returns john's record" do
+    users(:john).should be_an(User)
+  end
+
+  it "returns myapp's record" do
+    projects(:myapp).user.should == users(:john)
+  end
+end
+```
+
+That's it!
+
+## 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,28 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+
+case ENV["TEST_FRAMEWORK"]
+when "rspec"
+  require "rspec/core/rake_task"
+  RSpec::Core::RakeTask.new
+
+  task default: :spec
+when "minitest"
+  require "rake/testtask"
+
+  Rake::TestTask.new(:test) do |t|
+    t.libs << "test"
+    t.libs << "lib"
+    t.test_files = FileList["test/**/*_test.rb"]
+    t.verbose = false
+    t.warning = false
+  end
+
+  task default: :test
+else
+  task :default do
+    system "TEST_FRAMEWORK=rspec bundle exec rake spec"
+    system "TEST_FRAMEWORK=minitest bundle exec rake test"
+  end
+end

data/lib/fixture_bot/extension.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module FactoryBot
+  module Syntax
+    module Default
+      class DSL
+        def preload(table, &block)
+          ::FixtureBot::FixtureCreator.tables[table] ||= []
+          ::FixtureBot::FixtureCreator.tables[table] << block
+        end
+      end
+    end
+  end
+end

data/lib/fixture_bot/fixture_creator.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module FixtureBot
+  module FixtureCreator
+    extend ::FactoryBot::Syntax::Methods
+    extend ::FixtureBot::Helpers
+
+    class << self
+      attr_accessor :tables, :record_ids, :fixtures, :fixtures_with_id
+    end
+
+    self.tables = {}
+    self.record_ids = {}
+
+    module_function
+
+    def load_to_db
+      tmp_fixtures = []
+      tmp_fixtures_with_id = []
+
+      tables.each do |table, blocks|
+        table_preload = TableLoader.new(table)
+
+        blocks.each do |block|
+          table_preload.instance_eval(&block)
+        end
+
+        tmp_fixtures.concat(table_preload.fixtures)
+        tmp_fixtures_with_id.concat(table_preload.fixtures_with_id)
+      end
+
+      self.fixtures = tmp_fixtures.to_h
+      self.fixtures_with_id = tmp_fixtures_with_id.to_h
+
+      ::ActiveRecord::Base.connection.transaction requires_new: true do
+        fixtures_with_id.each do |key, block|
+          table, fixture_name = key.split("/")
+          fixture_with_id(table.to_sym, fixture_name.to_sym, &block)
+        end
+
+        fixtures.each do |key, block|
+          table, fixture_name = key.split("/")
+          fixture(table.to_sym, fixture_name.to_sym, &block)
+        end
+      end
+    end
+
+    private def force_load_fixture(table, name)
+      if (block = fixtures["#{table}/#{name}"] || fixtures_with_id["#{table}/#{name}"])
+        fixture(table, name, &block)
+      end
+    end
+
+    private def fixture(table, name, &)
+      record_ids[table] ||= {}
+      record_ids[table][name] ||=
+        begin
+          model = instance_eval(&)
+          [model.class.name, model.id]
+        end
+    end
+
+    private def fixture_with_id(table, name, &)
+      _, record_id = fixture(table, name, &)
+      ::ActiveRecord::Base.connection.execute <<~SQL
+        SELECT setval(pg_get_serial_sequence('#{table}', 'id'), GREATEST(#{record_id}, nextval(pg_get_serial_sequence('#{table}', 'id'))))
+      SQL
+    end
+  end
+end

data/lib/fixture_bot/helpers.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module FixtureBot
+  module Helpers
+    def self.included(_base)
+      ::FixtureBot::FixtureCreator.tables.each_key do |table|
+        module_eval <<-RUBY, __FILE__, __LINE__ + 1
+          # def users(name)
+          #   fixture_get(name, :users)
+          # end
+          def #{table}(name)
+            fixture_get(name, :#{table})
+          end
+        RUBY
+      end
+    end
+
+    private def fixture_get(name, table)
+      model_name, model_id = FixtureCreator.record_ids.dig(table, name) || FixtureCreator.force_load_fixture(table, name)
+      if model_id
+        Object.const_get(model_name).find(model_id)
+      else
+        raise "Couldn't find fixture #{table}/#{name}"
+      end
+    end
+  end
+end

data/lib/fixture_bot/minitest.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "minitest"
+require "factory_bot/syntax/methods"
+
+module FixtureBot
+  module Preload
+    def self.minitest
+      ::FixtureBot.clean
+      ::FixtureBot.run
+    end
+
+    module MinitestSetup
+      def setup
+        ::FixtureBot.reload_factories
+        super
+      end
+    end
+
+    ::Minitest::Test.include Helpers
+    ::Minitest::Test.prepend MinitestSetup
+  end
+end

data/lib/fixture_bot/rspec.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "rspec/core"
+require "factory_bot/syntax/methods"
+
+RSpec.configure do |config|
+  config.include FixtureBot::Helpers
+
+  config.before(:suite) do
+    FixtureBot.run
+  end
+end

data/lib/fixture_bot/table_loader.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module FixtureBot
+  class TableLoader
+    attr_reader :table, :fixtures, :fixtures_with_id
+
+    def initialize(table)
+      @table = table
+      @fixtures = []
+      @fixtures_with_id = []
+    end
+
+    def fixture(name, &block)
+      @fixtures << ["#{table}/#{name}", block]
+    end
+
+    def fixture_with_id(name, &block)
+      @fixtures_with_id << ["#{table}/#{name}", block]
+    end
+  end
+end

data/lib/fixture_bot/version.rb

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

data/lib/fixture_bot.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "factory_bot"
+require "active_record"
+
+module FixtureBot
+  require "fixture_bot/helpers"
+  require "fixture_bot/fixture_creator"
+  require "fixture_bot/table_loader"
+  require "fixture_bot/version"
+  require "fixture_bot/rspec" if defined?(RSpec)
+  require "fixture_bot/minitest" if defined?(Minitest)
+  require "fixture_bot/extension"
+
+  module_function
+
+  def after_load_fixtures(&block)
+    @after_load_fixtures = block
+  end
+
+  def run
+    cached_mtime, cached_record_ids = cached_fixtures
+    if cached_mtime && cached_mtime == max_mtime_fixtures
+      puts "Cache load fixtures".yellow
+
+      FixtureBot::FixtureCreator.record_ids = Marshal.load(cached_record_ids)
+      define_fixture_helpers
+    else
+      puts "Full load fixtures".yellow
+
+      clean_db
+      load_models
+      define_fixture_helpers
+      FixtureBot::FixtureCreator.load_to_db
+      @after_load_fixtures&.call
+      caching_max_mtime_fixtures(Marshal.dump(FixtureBot::FixtureCreator.record_ids))
+    end
+  end
+
+  def max_mtime_fixtures
+    @max_mtime_fixtures ||=
+      FactoryBot.definition_file_paths.flat_map { |path|
+        directory_path = File.expand_path(path)
+
+        if File.directory?(directory_path)
+          Dir[File.join(directory_path, "**", "*.rb")].map { |file| File.mtime(file) }
+        end
+      }.compact.max.round(6)
+  end
+
+  def cached_fixtures
+    connection.query(<<-SQL).first
+      CREATE TABLE IF NOT EXISTS __factory_bot_preload_cache_v1(fixtures_time timestamptz, fixtures_dump bytea);
+      SELECT fixtures_time, fixtures_dump FROM __factory_bot_preload_cache_v1
+    SQL
+  end
+
+  def caching_max_mtime_fixtures(dump_record_ids)
+    connection.execute <<-SQL
+      TRUNCATE TABLE __factory_bot_preload_cache_v1;
+      INSERT INTO __factory_bot_preload_cache_v1 VALUES ('#{max_mtime_fixtures.iso8601(6)}', '#{connection.raw_connection.escape_bytea(dump_record_ids)}')
+    SQL
+  end
+
+  def load_models
+    return unless defined?(Rails)
+
+    Dir[Rails.application.root.join("app/models/**/*.rb")].each do |file|
+      require_dependency file
+    end
+  end
+
+  def define_fixture_helpers
+    ::FactoryBot::SyntaxRunner.include(::FixtureBot::Helpers)
+  end
+
+  RESERVED_TABLES = %w[
+    ar_internal_metadata
+    schema_migrations
+  ].freeze
+
+  def clean_db
+    tables = connection.tables - RESERVED_TABLES
+
+    query =
+      case connection.adapter_name
+      when "SQLite"
+        tables.map { |table| "DELETE FROM #{connection.quote_table_name(table)}" }.join(";")
+      when "PostgreSQL"
+        "TRUNCATE TABLE #{tables.map { |table| connection.quote_table_name(table) }.join(',')} RESTART IDENTITY CASCADE"
+      else
+        "TRUNCATE TABLE #{tables.map { |table| connection.quote_table_name(table) }.join(',')}"
+      end
+
+    connection.disable_referential_integrity do
+      connection.execute(query)
+    end
+  end
+
+  def connection
+    ::ActiveRecord::Base.connection
+  end
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: fixture_bot
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ermolaev Andrey
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-09-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: factory_bot
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Fast and easy to maintain fixtures inside factories
+email:
+- andruhafirst@yandex.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/fixture_bot.rb
+- lib/fixture_bot/extension.rb
+- lib/fixture_bot/fixture_creator.rb
+- lib/fixture_bot/helpers.rb
+- lib/fixture_bot/minitest.rb
+- lib/fixture_bot/rspec.rb
+- lib/fixture_bot/table_loader.rb
+- lib/fixture_bot/version.rb
+homepage: https://github.com/corp-gp/fixture_bot
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/corp-gp/fixture_bot
+  source_code_uri: https://github.com/corp-gp/fixture_bot
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.17
+signing_key:
+specification_version: 4
+summary: fixtures inside factories
+test_files: []