factory_hoist 0.1.0

data/lib/factory_hoist.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require "factory_bot"
+require "minitest"
+require "monitor"
+require "rspec/core"
+require_relative "factory_hoist/configuration"
+require_relative "factory_hoist/pcg32"
+require_relative "factory_hoist/runtime"
+require_relative "factory_hoist/stats"
+require_relative "factory_hoist/version"
+
+module FactoryHoist
+  RANDOM_MONITOR = Monitor.new
+
+  class Error < StandardError; end
+  class BulkWriteError < Error; end
+  class DuplicateHoistError < Error; end
+  class FactoryUnavailableError < Error; end
+  class MaterializationError < Error; end
+  class SharedDataMutationError < Error; end
+
+  class << self
+    attr_writer :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def reset!
+      @configuration = Configuration.new
+      Thread.current[:factory_hoist_random] = nil
+      stats.reset!
+      Runtime.reset!
+      FastBuild.reset! if defined?(FastBuild)
+    end
+
+    def build(name, *traits, **attributes, &block)
+      result = if defined?(::Faker::Config)
+        with_random_source(random) { build_factory(name, traits, attributes) }
+      else
+        build_factory(name, traits, attributes)
+      end
+
+      result.tap { |record| block&.call(record) }
+    end
+
+    def create(name, *traits, **attributes, &block)
+      run_factory(:create, name, traits, attributes).tap { |record| block&.call(record) }
+    end
+
+    def build_list(name, count, *traits, **attributes, &block)
+      Array.new(count) do |index|
+        build(name, *traits, **attributes).tap { |record| block&.call(record, index) }
+      end
+    end
+
+    def create_list(name, count, *traits, **attributes, &block)
+      Array.new(count) do |index|
+        create(name, *traits, **attributes).tap { |record| block&.call(record, index) }
+      end
+    end
+
+    def unsafe_bulk_insert(name, count, *traits, **attributes)
+      require_relative "factory_hoist/bulk_writer"
+      BulkWriter.call(name, count, traits, attributes)
+    end
+
+    def clone_database(source:, target:, adapter:)
+      require_relative "factory_hoist/parallel_database"
+      ParallelDatabase.clone(source: source, target: target, adapter: adapter)
+    end
+
+    def advise(*paths, io: $stdout)
+      require_relative "factory_hoist/advisor"
+      Advisor.new(paths.empty? ? ["spec"] : paths).print(io)
+    end
+
+    def stats
+      @stats ||= Stats.new
+    end
+
+    def random
+      Thread.current[:factory_hoist_random] ||= PCG32.new(configuration.suite_seed)
+    end
+
+    def with_seed(seed)
+      with_random_source(PCG32.new(seed)) { yield }
+    end
+
+    private
+
+    def build_factory(name, traits, attributes)
+      adapter = configuration.factory_adapter
+      return adapter.call(:build, name, traits, attributes) if adapter
+
+      require_relative "factory_hoist/fast_build" unless defined?(::FactoryHoist::FastBuild)
+      result = FastBuild.call(name, traits, attributes)
+      return result unless result.equal?(FastBuild::FALLBACK)
+
+      call_factory_bot(:build, name, traits, attributes)
+    end
+
+    def with_random_source(source)
+      faker_config = ::Faker::Config if defined?(::Faker::Config)
+      if RANDOM_MONITOR.mon_owned? && Thread.current[:factory_hoist_random].equal?(source) &&
+          (!faker_config || faker_config.random.equal?(source))
+        return yield
+      end
+      return scope_random_source(source) { yield } unless faker_config
+
+      RANDOM_MONITOR.synchronize { scope_random_source(source) { yield } }
+    end
+
+    def scope_random_source(source)
+      previous = Thread.current[:factory_hoist_random]
+      Thread.current[:factory_hoist_random] = source
+      faker_config = ::Faker::Config if defined?(::Faker::Config)
+      previous_faker = faker_config.random if faker_config
+      faker_config.random = source if faker_config
+      yield
+    ensure
+      faker_config.random = previous_faker if faker_config
+      Thread.current[:factory_hoist_random] = previous
+    end
+
+    def run_factory(strategy, name, traits, attributes)
+      adapter = configuration.factory_adapter
+      adapter ||= default_factory_adapter
+      adapter.call(strategy, name, traits, attributes)
+    end
+
+    def default_factory_adapter
+      return method(:call_factory_bot) if defined?(::FactoryBot)
+
+      raise FactoryUnavailableError,
+        "configure FactoryHoist.configuration.factory_adapter or require factory_bot"
+    end
+
+    def call_factory_bot(strategy, name, traits, attributes)
+      ::FactoryBot.public_send(strategy, name, *traits, **attributes)
+    end
+  end
+end
+
+require_relative "factory_hoist/rspec"
+require_relative "factory_hoist/minitest"

data/script/verify_postgresql

@@ -0,0 +1,102 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "active_record"
+require "factory_hoist"
+
+ActiveRecord::Base.establish_connection(
+  ENV.fetch("DATABASE_URL", "postgresql:///postgres")
+)
+connection = ActiveRecord::Base.connection
+connection.execute <<~SQL
+  CREATE TEMP TABLE factory_hoist_subxid_check (
+    id bigserial PRIMARY KEY,
+    name text NOT NULL
+  ) ON COMMIT PRESERVE ROWS
+SQL
+
+model = Class.new(ActiveRecord::Base) do
+  self.table_name = "factory_hoist_subxid_check"
+end
+FactoryHoist.reset!
+FactoryHoist.configuration.subxid_budget = 60
+FactoryHoist.configuration.factory_adapter = lambda do |_strategy, _name, _traits, attributes|
+  model.create!({name: "hoisted"}.merge(attributes))
+end
+
+definition = FactoryHoist::Definition.new(:record, :record, [], {}, nil, "postgres check")
+session = FactoryHoist::Runtime::Session.new
+group = Object.new
+transaction_ids = []
+subtrans_reads = lambda do
+  connection.select_value("SELECT blks_read FROM pg_stat_slru WHERE name = 'Subtrans'").to_i
+end
+before_reads = subtrans_reads.call
+checkpoint = connection.select_value("SELECT next_xid::text FROM pg_control_checkpoint()")
+
+session.enter(group, {record: definition})
+61.times do
+  example = Object.new
+  example.define_singleton_method(:run) do
+    connection.execute("INSERT INTO factory_hoist_subxid_check(name) VALUES ('example')")
+    transaction_ids << connection.select_value("SELECT txid_current_if_assigned()")
+    raise "backend xid is not visible" unless connection.select_value(<<~SQL)
+      SELECT backend_xid::text FROM pg_stat_activity WHERE pid = pg_backend_pid()
+    SQL
+  end
+  session.around_example(example)
+end
+session.leave(group)
+
+raise "outer transaction was not rebuilt" unless transaction_ids.uniq.size == 2
+raise "unexpected subtrans disk read" unless subtrans_reads.call == before_reads
+raise "hoisted rows leaked" unless model.count.zero?
+raise "pg_control_checkpoint unavailable" unless checkpoint
+
+FactoryHoist.configuration.subxid_budget = 1
+context_group = Object.new
+session.enter(context_group, {record: definition}, materialize: false)
+model.create!(name: "context setup")
+session.materialize(context_group)
+2.times do
+  example = Object.new
+  example.define_singleton_method(:run) do
+    raise "context setup was lost during rebuild" unless model.count == 2
+  end
+  session.around_example(example)
+end
+session.leave(context_group)
+raise "context setup leaked" unless model.count.zero?
+
+FactoryBot.define do
+  factory :factory_hoist_postgres_bulk_check, class: model do
+    name { "bulk" }
+  end
+end
+connection.transaction(requires_new: true) do
+  begin
+    FactoryHoist.unsafe_bulk_insert(:factory_hoist_postgres_bulk_check, 2, name: nil)
+  rescue FactoryHoist::BulkWriteError => error
+    raise "bulk failure location missing" unless error.message.include?("row 0")
+  else
+    raise "invalid bulk insert unexpectedly succeeded"
+  end
+  model.create!(name: "transaction remains usable")
+  raise ActiveRecord::Rollback
+end
+raise "bulk verification leaked rows" unless model.count.zero?
+
+FactoryHoist.configuration.factory_adapter = lambda do |_strategy, _name, _traits, attributes|
+  model.create!({name: "reset"}.merge(attributes))
+end
+reset_definition = FactoryHoist::Definition.new(:record, :record, [], {}, nil, "reset check")
+FactoryHoist::Runtime.current.enter(Object.new, {record: reset_definition})
+raise "reset setup failed" unless model.count == 1
+
+FactoryHoist.reset!
+
+raise "reset left a transaction open" if connection.transaction_open?
+raise "reset leaked rows" unless model.count.zero?
+
+puts "PostgreSQL verified: subxid budget, context state, bulk failure recovery, and reset cleanup"

data/script/verify_postgresql_clone

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "pg"
+require "factory_hoist"
+
+suffix = "#{Process.pid}_#{Time.now.to_i}"
+source = "factory_hoist_source_#{suffix}"
+target = "factory_hoist_worker_#{suffix}"
+begin
+  admin = PG.connect(dbname: "postgres")
+  admin.exec("CREATE DATABASE #{admin.quote_ident(source)}")
+  seed = PG.connect(dbname: source)
+  seed.exec("CREATE TABLE proof(value text NOT NULL)")
+  seed.exec("INSERT INTO proof VALUES ('cloned')")
+
+  begin
+    FactoryHoist.clone_database(
+      source: "postgresql:///#{source}",
+      target: target,
+      adapter: :postgresql
+    )
+  rescue FactoryHoist::Error => error
+    raise unless error.message.include?("active connection")
+  else
+    raise "clone accepted an active source connection"
+  end
+  seed.close
+
+  FactoryHoist.clone_database(
+    source: "postgresql:///#{source}",
+    target: target,
+    adapter: :postgresql
+  )
+  worker = PG.connect(dbname: target)
+  raise "template data missing" unless worker.exec("SELECT value FROM proof").getvalue(0, 0) == "cloned"
+  worker.close
+
+  begin
+    FactoryHoist.clone_database(
+      source: "postgresql:///#{source}",
+      target: target,
+      adapter: :postgresql
+    )
+  rescue FactoryHoist::Error => error
+    raise unless error.message.include?("already exists")
+  else
+    raise "clone overwrote an existing target"
+  end
+
+  puts "PostgreSQL template clone and refusal paths verified: #{source} -> #{target}"
+ensure
+  worker&.close unless worker&.finished?
+  seed&.close unless seed&.finished?
+  if admin
+    admin.exec("DROP DATABASE IF EXISTS #{admin.quote_ident(target)} WITH (FORCE)") if target
+    admin.exec("DROP DATABASE IF EXISTS #{admin.quote_ident(source)} WITH (FORCE)") if source
+    admin.close
+  end
+end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: factory_hoist
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yudai Takada
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: factory_bot
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.5'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.5'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+- !ruby/object:Gem::Dependency
+  name: rspec-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.12'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.12'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
+description: Hoists FactoryBot records to RSpec group boundaries while isolating each
+  example.
+email:
+- t.yudai92@gmail.com
+executables:
+- factory_hoist
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- bench/fast_build.rb
+- bench/phase0_synthetic.rb
+- docs/adversarial-audit.md
+- docs/phase0-synthetic.md
+- exe/factory_hoist
+- lib/factory_hoist.rb
+- lib/factory_hoist/advisor.rb
+- lib/factory_hoist/bulk_writer.rb
+- lib/factory_hoist/compatibility.rb
+- lib/factory_hoist/configuration.rb
+- lib/factory_hoist/database_snapshot.rb
+- lib/factory_hoist/deep_copy.rb
+- lib/factory_hoist/definition.rb
+- lib/factory_hoist/fast_build.rb
+- lib/factory_hoist/minitest.rb
+- lib/factory_hoist/parallel_database.rb
+- lib/factory_hoist/pcg32.rb
+- lib/factory_hoist/rspec.rb
+- lib/factory_hoist/runtime.rb
+- lib/factory_hoist/scheduler.rb
+- lib/factory_hoist/stats.rb
+- lib/factory_hoist/transaction.rb
+- lib/factory_hoist/version.rb
+- script/verify_postgresql
+- script/verify_postgresql_clone
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.19
+specification_version: 4
+summary: Share factory data safely across RSpec examples
+test_files: []