fixture_bot 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 882daa77b1a9840f2179c979b5bd51e09782e7ef011d28dc761bbbdd65789942
-  data.tar.gz: 0c8957cc5ff3f0c412ae7e9d85acc41baf407b7090de7f2e55450e77573ae13e
+  metadata.gz: 8eb18affd0227587d706dcbd9f598b1118f175cba7f0b7abd29ddf57618a42af
+  data.tar.gz: 23f67409d1c4bde7b00e757cacfbfc34885954915e492f4730c8c3c5dd50050b
 SHA512:
-  metadata.gz: e4c795d92c941773f0af08ffa32d289a0d6b7ae2421cfc3cb6934f2c94724d53c64078d0b179e25761ec534a8a5a96b67333146eb4bdbb0ee926a0a6ba2a85ec
-  data.tar.gz: 9869573d964e08fb7f7632f3a624688f48a066f325a87baa51ab789120cc286d8f165001f0954817aeaf4151aaec6e803c1e7247b288dbc13824a103fb94fb6b
+  metadata.gz: 726a157de2ec6dd416daeba4783023754cce5ebc47982364a82ed0cf1962a34b4e5ac66f528fc335650a5c2f9258a5fba11d3e4ade6d1787c1b4632d03c9cd08
+  data.tar.gz: a724d0bf57b9c2ae3afea43d65d38b626394807cd8494df0c36f1f23417ad6bca42c92a4152447f0aa679dbaac1191256b59665b396d3da50ce32590c61af41e

data/README.md

@@ -1,195 +1,105 @@
-# factory_bot-preload
+# `fixture_bot`
 
-[![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)
+Improve the performance of your tests, as factories generate and insert data into the database every time, it can be slow. See [benchmarks](#Benchmarks).
 
-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).
+Problems using [Rails fixtures](https://api.rubyonrails.org/classes/ActiveRecord/FixtureSet.html):
 
-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).
+- No data validation
+- Long loading of fixtures (for one or all tests - equally long)
+- YML format (no reuse code)
+- heavy support for fixtures and factories together
 
 ### Installation
 
-Add both FB and FBP to your Gemfile:
-
 ```ruby
-source "https://rubygems.org"
-
-gem "rails"
-
-group :test, :development do
+group :test 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:
+To define your fixture in factories, 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
+  
+  preload(:users) do
+    fixture_with_id(:first) { create(:user, id: 1) }
+    fixture(:john) { create(:user) }
+    fixture(:with_gmail) { create(:user, email: "email@gmail.com") }
   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
+    user { users(:with_gmail) }
   end
 
-  preload do
-    fixture(:john) { create(:user) }
+  preload(:users) do
     fixture(:myapp) { create(:project, user: users(:john)) }
   end
 end
 ```
 
-You can also use preloaded factories on factory definitions.
+
+### RSpec usage
 
 ```ruby
-FactoryBot.define do
-  factory :user do
-    # ...
+require "spec_helper"
+
+describe User do
+  let(:user) { users(:john) }
+
+  it "returns john's record" do
+    expect(users(:john)).to be_a User
   end
 
-  factory :projects do
-    name "My Project"
-    user { users(:john) }
+  it "returns myapp's record" do
+    expect(projects(:myapp).user).to eq users(:john)
   end
 
-  preload do
-    fixture(:john) { create(:user) }
-    fixture(:myapp) { create(:project, user: users(:john)) }
+  it "each call fixture return new object" do
+    expect(user.object_id).not_to eq users(:john).object_id
   end
 end
 ```
 
+### RSpec Setup
 
-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
+On your `spec/support/factory_bot.rb` file
 
 ```ruby
-class User
-  ADMIN_ID = 10
+require "fixture_bot" # the order is important, it must be before loaded factories
+require "factory_bot_rails"
 
-  def can_edit_article?
-    id == ADMIN_ID
-  end
+FactoryBot::SyntaxRunner.class_eval do
+  include RSpec::Mocks::ExampleMethods
 end
-```
 
-```ruby
-FactoryBot.define do
-  factory :user do
-    # ...
-  end
-
-  preload do
-    fixture(:john) { create(:user) }
-    fixture_stub_const(:admin, :ADMIN_ID) { create(:user) }
-  end
+RSpec.configure do |config|
+  config.include FactoryBot::Syntax::Methods
 end
 ```
 
-```ruby
-describe User do
-  let(:admin) { users(:admin) }
-
-  it "admin can edit article" do
-    expect(admin).to be_can_edit_article
-  end
-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
 
-Like Rails fixtures, FBP will define methods for each model. You can use it on
-your examples and alike.
+```ruby
+# First, load fixture_bot
+require "fixture_bot"
+FixtureBot.minitest
+```
 
 ```ruby
 require "test_helper"
@@ -205,25 +115,42 @@ class UserTest < ActiveSupport::TestCase
 end
 ```
 
-Or if you're using RSpec:
-
+## Callbacks
 ```ruby
-require "spec_helper"
+FixtureBot.after_load_fixtures do
+  # code uses fixtures
+end
+```
 
-describe User do
-  let(:user) { users(:john) }
+## Benchmarks
+#### factories vs fixtures
 
-  it "returns john's record" do
-    users(:john).should be_an(User)
-  end
+simple model with 10 fields
+```ruby
+Benchmark.ips do |x|
+  x.report("fixture") { brands(:lux) }.   # fixture:     4666.2 i/s
+  x.report("factory") { create(:brand) }  # factory:     1077.8 i/s - 4.33x  slower
+  x.compare!
+end
+```
 
-  it "returns myapp's record" do
-    projects(:myapp).user.should == users(:john)
-  end
+user model with 40+ fields, 1 association
+```ruby
+Benchmark.ips do |x|
+  x.report("fixture") { users(:with_post_index)} # fixture:     3395.4 i/s
+  x.report("factory") { create(:user) }          # factory:      159.6 i/s - 21.27x  slower
+  x.compare!
 end
 ```
 
-That's it!
+product model with 40+ fields, 5+ associations
+```ruby
+Benchmark.ips do |x|
+  x.report("fixture") { products(:available) }         # fixture:     3564.3 i/s
+  x.report("factory") { create(:product, :available) } # factory:       67.7 i/s - 52.68x  slower
+  x.compare!
+end
+```
 
 ## License
 

data/lib/fixture_bot/fixture_creator.rb

@@ -62,9 +62,12 @@ module FixtureBot
 
     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
+
+      if ::ActiveRecord::Base.connection.adapter_name == "PostgreSQL"
+        ::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
 end

data/lib/fixture_bot/version.rb

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

data/lib/fixture_bot.rb

@@ -21,12 +21,12 @@ module FixtureBot
   def run
     cached_mtime, cached_record_ids = cached_fixtures
     if cached_mtime && cached_mtime == max_mtime_fixtures
-      puts "Cache load fixtures".yellow
+      colored_output "Cache load fixtures"
 
-      FixtureBot::FixtureCreator.record_ids = Marshal.load(cached_record_ids)
+      FixtureBot::FixtureCreator.record_ids = Marshal.load(Base64.decode64(cached_record_ids))
       define_fixture_helpers
     else
-      puts "Full load fixtures".yellow
+      colored_output "Full load fixtures"
 
       clean_db
       load_models
@@ -50,15 +50,15 @@ module FixtureBot
 
   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
+      CREATE TABLE IF NOT EXISTS __fixture_bot_cache_v1(fixtures_time timestamptz, fixtures_dump bytea);
+      SELECT fixtures_time, fixtures_dump FROM __fixture_bot_cache_v1
     SQL
   end
 
   def caching_max_mtime_fixtures(dump_record_ids)
+    truncate_tables(["__fixture_bot_cache_v1"])
     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)}')
+      INSERT INTO __fixture_bot_cache_v1 VALUES ('#{max_mtime_fixtures.iso8601(6)}', '#{Base64.encode64(dump_record_ids)}')
     SQL
   end
 
@@ -80,24 +80,27 @@ module FixtureBot
   ].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)
+      connection.execute(truncate_tables(connection.tables - RESERVED_TABLES))
     end
   end
 
   def connection
     ::ActiveRecord::Base.connection
   end
+
+  def truncate_tables(tables)
+    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
+  end
+
+  def colored_output(text)
+    puts "\e[33m#{text}\e[0m"
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fixture_bot
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Ermolaev Andrey
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-09-29 00:00:00.000000000 Z
+date: 2024-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord