familia 2.0.0.pre19 → 2.0.0.pre21

data/try/thread_safety/class_connection_chain_race_try.rb

@@ -0,0 +1,265 @@
+# try/thread_safety/class_connection_chain_race_try.rb
+#
+# frozen_string_literal: true
+
+require_relative '../support/helpers/test_helpers'
+
+# Thread safety tests for class-level connection chain initialization
+#
+# Tests concurrent class-level connection chain initialization to ensure
+# that each Horreum subclass properly initializes its own connection chain
+# without race conditions or shared state issues.
+#
+# These tests verify:
+# 1. Concurrent class-level connection chain initialization
+# 2. Multiple model classes initialized concurrently
+# 3. Inheritance chain with concurrent access
+# 4. Connection chain isolation between classes
+
+## Concurrent class-level connection chain initialization
+class TestModel1 < Familia::Horreum
+  identifier_field :test_id
+  field :test_id
+
+  def init
+    @test_id ||= SecureRandom.hex(4)
+  end
+  field :name
+end
+
+TestModel1.instance_variable_set(:@class_connection_chain, nil)
+# Mutex is now initialized eagerly in Connection.included hook
+barrier = Concurrent::CyclicBarrier.new(50)
+chains = Concurrent::Array.new
+
+threads = 50.times.map do
+  Thread.new do
+    barrier.wait
+    client = TestModel1.dbclient
+    # Store the actual connection chain object ID to detect singleton violations
+    chain = TestModel1.instance_variable_get(:@class_connection_chain)
+    chains << chain.object_id
+  end
+end
+
+threads.each(&:join)
+# Test multiple invariants (pattern from middleware tests):
+# - No nil entries (corruption check)
+# - All chains are same object (singleton property)
+# - Got expected number of results
+[chains.any?(nil), chains.uniq.size, chains.size]
+#=> [false, 1, 50]
+
+
+## Multiple model classes initialized concurrently
+barrier = Concurrent::CyclicBarrier.new(10)
+models = Concurrent::Array.new
+
+threads = 10.times.map do |i|
+  Thread.new do
+    model_class = Class.new(Familia::Horreum) do
+      def self.name
+        "ConcurrentTestModel#{Thread.current.object_id}"
+      end
+
+      identifier_field :test_id
+      field :test_id
+      field :value
+
+      def init
+        @test_id ||= SecureRandom.hex(4)
+      end
+    end
+
+    barrier.wait
+    client = model_class.dbclient
+    models << [model_class.name, client.class.name]
+  end
+end
+
+threads.each(&:join)
+models.size
+#=> 10
+
+
+## Connection chain per-class isolation
+class TestModel2 < Familia::Horreum
+  identifier_field :test_id
+  field :test_id
+
+  def init
+    @test_id ||= SecureRandom.hex(4)
+  end
+  field :name
+end
+
+class TestModel3 < Familia::Horreum
+  identifier_field :test_id
+  field :test_id
+
+  def init
+    @test_id ||= SecureRandom.hex(4)
+  end
+  field :name
+end
+
+TestModel2.instance_variable_set(:@class_connection_chain, nil)
+# Mutex is now initialized eagerly in Connection.included hook
+TestModel3.instance_variable_set(:@class_connection_chain, nil)
+# Mutex is now initialized eagerly in Connection.included hook
+
+barrier = Concurrent::CyclicBarrier.new(20)
+results = Concurrent::Array.new
+
+threads = 20.times.map do |i|
+  Thread.new do
+    barrier.wait
+    if i.even?
+      client = TestModel2.dbclient
+      results << [:model2, client.class.name]
+    else
+      client = TestModel3.dbclient
+      results << [:model3, client.class.name]
+    end
+  end
+end
+
+threads.each(&:join)
+results.size
+#=> 20
+
+
+## Inheritance chain with concurrent access
+class BaseModel < Familia::Horreum
+  identifier_field :test_id
+  field :test_id
+
+  def init
+    @test_id ||= SecureRandom.hex(4)
+  end
+  field :base_field
+end
+
+class ChildModel1 < BaseModel
+  field :child_field
+end
+
+class ChildModel2 < BaseModel
+  field :other_field
+end
+
+ChildModel1.instance_variable_set(:@class_connection_chain, nil)
+# Mutex is now initialized eagerly in Connection.included hook
+ChildModel2.instance_variable_set(:@class_connection_chain, nil)
+# Mutex is now initialized eagerly in Connection.included hook
+
+barrier = Concurrent::CyclicBarrier.new(30)
+chains = Concurrent::Array.new
+
+threads = 30.times.map do |i|
+  Thread.new do
+    barrier.wait
+    case i % 3
+    when 0
+      client = BaseModel.dbclient
+      chains << [:base, client.class.name]
+    when 1
+      client = ChildModel1.dbclient
+      chains << [:child1, client.class.name]
+    when 2
+      client = ChildModel2.dbclient
+      chains << [:child2, client.class.name]
+    end
+  end
+end
+
+threads.each(&:join)
+chains.size
+#=> 30
+
+## Concurrent database operations through class connection chain
+class OperationTestModel < Familia::Horreum
+  identifier_field :test_id
+  field :test_id
+  field :value
+end
+
+barrier = Concurrent::CyclicBarrier.new(25)
+results = Concurrent::Array.new
+
+threads = 25.times.map do |i|
+  Thread.new do
+    barrier.wait
+    obj = OperationTestModel.new(test_id: "test_#{i}", value: i)
+    obj.save
+    results << obj.test_id
+  end
+end
+
+threads.each(&:join)
+results.size
+#=> 25
+
+## Class connection chain rebuilds after reconnect
+class ReconnectTestModel < Familia::Horreum
+  identifier_field :test_id
+  field :test_id
+
+  def init
+    @test_id ||= SecureRandom.hex(4)
+  end
+  field :name
+end
+
+ReconnectTestModel.instance_variable_set(:@class_connection_chain, nil)
+# Mutex is now initialized eagerly in Connection.included hook
+barrier = Concurrent::CyclicBarrier.new(20)
+results = Concurrent::Array.new
+
+threads = 20.times.map do |i|
+  Thread.new do
+    barrier.wait
+    if i < 5
+      # Some threads trigger reconnect
+      Familia.reconnect!
+    end
+    # All threads access the chain
+    client = ReconnectTestModel.dbclient
+    results << client.class.name
+  end
+end
+
+threads.each(&:join)
+results.size
+#=> 20
+
+
+## Rapid sequential access to class connection chain
+class RapidAccessModel < Familia::Horreum
+  identifier_field :test_id
+  field :test_id
+
+  def init
+    @test_id ||= SecureRandom.hex(4)
+  end
+  field :value
+end
+
+barrier = Concurrent::CyclicBarrier.new(15)
+access_counts = Concurrent::Array.new
+
+threads = 15.times.map do
+  Thread.new do
+    barrier.wait
+    count = 0
+    20.times do
+      RapidAccessModel.dbclient
+      count += 1
+    end
+    access_counts << count
+  end
+end
+
+threads.each(&:join)
+access_counts.size
+#=> 15

data/try/thread_safety/connection_chain_race_try.rb

@@ -0,0 +1,148 @@
+# try/thread_safety/connection_chain_race_try.rb
+#
+# frozen_string_literal: true
+
+require_relative '../support/helpers/test_helpers'
+
+# Thread safety tests for connection chain lazy initialization
+#
+# Tests concurrent connection chain initialization to ensure that the
+# lazy initialization pattern (@connection_chain ||= build_connection_chain)
+# doesn't result in duplicate chain instances or inconsistent state.
+#
+# These tests verify:
+# 1. Concurrent module-level connection chain initialization
+# 2. Connection chain consistency after concurrent reconnect
+# 3. Thread-safe chain access during reconnection
+
+@original_chain = nil
+
+# Setup: Store original connection chain
+@original_chain = Familia.instance_variable_get(:@connection_chain)
+
+## Concurrent connection chain initialization builds only one chain
+Familia.instance_variable_set(:@connection_chain, nil)
+barrier = Concurrent::CyclicBarrier.new(50)
+chain_ids = Concurrent::Array.new
+
+threads = 50.times.map do
+  Thread.new do
+    barrier.wait
+    Familia.dbclient('redis://127.0.0.1:6379')  # Trigger chain initialization
+    chain_ids << Familia.instance_variable_get(:@connection_chain).object_id
+  end
+end
+
+threads.each(&:join)
+# Test multiple invariants:
+# - No nil entries (array corruption check from middleware tests)
+# - All threads see same connection chain object (singleton property)
+[chain_ids.any?(nil), chain_ids.uniq.size]
+#=> [false, 1]
+
+## Connection chain remains functional after concurrent access
+Familia.instance_variable_set(:@connection_chain, nil)
+barrier = Concurrent::CyclicBarrier.new(30)
+results = Concurrent::Array.new
+
+threads = 30.times.map do
+  Thread.new do
+    barrier.wait
+    begin
+      client = Familia.dbclient
+      result = client.call('PING')
+      results << result
+    rescue => e
+      results << e.class.name
+    end
+  end
+end
+
+threads.each(&:join)
+# Test multiple invariants (pattern from middleware tests):
+# - No nil entries (corruption check)
+# - All successful PONG responses (correctness check)
+[results.any?(nil), results.all? { |r| r == 'PONG' }]
+#=> [false, true]
+
+## Concurrent reconnect calls maintain chain consistency
+barrier = Concurrent::CyclicBarrier.new(20)
+errors = Concurrent::Array.new
+successes = Concurrent::Array.new
+
+threads = 20.times.map do |i|
+  Thread.new do
+    barrier.wait
+    begin
+      if i < 10
+        # Half the threads reconnect
+        Familia.reconnect!
+        successes << :reconnect
+      else
+        # Half access the chain
+        client = Familia.dbclient
+        client.call('PING')
+        successes << :ping
+      end
+    rescue => e
+      errors << e.class.name
+    end
+  end
+end
+
+threads.each(&:join)
+(successes.size >= 15)
+#=> true
+
+## Connection chain rebuilds correctly after nil assignment
+original = Familia.instance_variable_get(:@connection_chain)
+barrier = Concurrent::CyclicBarrier.new(40)
+results = Concurrent::Array.new
+
+threads = 40.times.map do |i|
+  Thread.new do
+    barrier.wait
+    if i == 0
+      # One thread clears the chain
+      Familia.instance_variable_set(:@connection_chain, nil)
+    end
+    # All threads try to use the chain
+    begin
+      client = Familia.dbclient
+      results << client.class.name
+    rescue => e
+      results << e.class.name
+    end
+  end
+end
+
+threads.each(&:join)
+# Test multiple invariants:
+# - No nil entries from concurrent chain rebuilding
+# - All got valid Redis instances (protected by Mutex)
+# - All are actually instances, not errors
+[results.any?(nil), results.all? { |r| r == 'Redis' }, results.size]
+#=> [false, true, 40]
+
+## Rapid sequential reconnects from multiple threads
+barrier = Concurrent::CyclicBarrier.new(10)
+reconnect_counts = Concurrent::Array.new
+
+threads = 10.times.map do
+  Thread.new do
+    barrier.wait
+    count = 0
+    10.times do
+      Familia.reconnect!
+      count += 1
+    end
+    reconnect_counts << count
+  end
+end
+
+threads.each(&:join)
+reconnect_counts.all? { |c| c == 10 }
+#=> true
+
+# Teardown: Restore original connection chain
+Familia.instance_variable_set(:@connection_chain, @original_chain)

data/try/thread_safety/encryption_manager_cache_race_try.rb

@@ -0,0 +1,166 @@
+# try/thread_safety/encryption_manager_cache_race_try.rb
+#
+# frozen_string_literal: true
+
+require_relative '../support/helpers/test_helpers'
+require 'base64'
+
+# Thread safety tests for encryption manager cache initialization
+#
+# Tests concurrent encryption manager cache access to ensure that only
+# a single Manager instance is created per algorithm even under high
+# concurrent load.
+#
+# These tests verify:
+# 1. Concurrent manager cache initialization (single algorithm)
+# 2. Multiple algorithms initialized concurrently
+# 3. Maximum contention with CyclicBarrier pattern
+# 4. Manager singleton property per algorithm
+
+# Setup encryption keys for testing
+test_keys = {
+  v1: Base64.strict_encode64('a' * 32),
+  v2: Base64.strict_encode64('b' * 32)
+}
+Familia.config.encryption_keys = test_keys
+Familia.config.current_key_version = :v1
+
+## Concurrent manager cache initialization for default algorithm
+# Reset the managers cache to nil to simulate first access
+Familia::Encryption.instance_variable_set(:@managers, nil)
+
+barrier = Concurrent::CyclicBarrier.new(50)
+managers = Concurrent::Array.new
+
+threads = 50.times.map do
+  Thread.new do
+    barrier.wait
+    # Get manager for default algorithm (nil)
+    mgr = Familia::Encryption.manager(algorithm: nil)
+    managers << mgr.object_id
+  end
+end
+
+threads.each(&:join)
+
+# All threads should get the same manager instance
+[managers.any?(nil), managers.uniq.size, managers.size]
+#=> [false, 1, 50]
+
+
+## Concurrent manager cache initialization for default algorithm only
+# Testing with just default (nil) algorithm to avoid provider availability issues
+Familia::Encryption.instance_variable_set(:@managers, nil)
+
+barrier = Concurrent::CyclicBarrier.new(30)
+results = Concurrent::Array.new
+
+threads = 30.times.map do |i|
+  Thread.new do
+    barrier.wait
+    # All use default algorithm for simplicity
+    mgr = Familia::Encryption.manager(algorithm: nil)
+    results << mgr.object_id
+  end
+end
+
+threads.each(&:join)
+
+# All threads should get the same manager instance
+[results.uniq.size, results.size]
+#=> [1, 30]
+
+
+## Maximum contention test with encryption operations
+Familia::Encryption.instance_variable_set(:@managers, nil)
+Familia::Encryption.reset_derivation_count!
+
+barrier = Concurrent::CyclicBarrier.new(50)
+@encrypt_errors = Concurrent::Array.new
+@encrypted_values = Concurrent::Array.new
+
+threads = 50.times.map do |i|
+  Thread.new do
+    begin
+      barrier.wait
+      # All threads encrypt concurrently, forcing manager cache access
+      plaintext = "secret-#{i}"
+      context = "test:#{i}"
+      encrypted = Familia::Encryption.encrypt(plaintext, context: context)
+      @encrypted_values << encrypted
+    rescue => e
+      @encrypt_errors << e
+    end
+  end
+end
+
+threads.each(&:join)
+
+# Verify no errors and all encryptions succeeded
+[@encrypt_errors.empty?, @encrypted_values.size]
+#=> [true, 50]
+
+
+## Manager singleton property maintained across concurrent access
+# Access the managers cache and verify singleton property
+managers_cache = Familia::Encryption.instance_variable_get(:@managers)
+
+# Should be a Concurrent::Map
+managers_cache.class.name
+#=> "Concurrent::Map"
+
+
+## Concurrent decryption operations with manager cache
+barrier = Concurrent::CyclicBarrier.new(25)
+@decrypted_values = Concurrent::Array.new
+@decrypt_errors = Concurrent::Array.new
+
+# First, create some encrypted values
+test_encrypted = 25.times.map do |i|
+  Familia::Encryption.encrypt("value-#{i}", context: "test:#{i}")
+end
+
+threads = 25.times.map do |i|
+  Thread.new do
+    begin
+      barrier.wait
+      decrypted = Familia::Encryption.decrypt(test_encrypted[i], context: "test:#{i}")
+      @decrypted_values << decrypted
+    rescue => e
+      @decrypt_errors << e
+    end
+  end
+end
+
+threads.each(&:join)
+
+# Verify no errors and all decryptions succeeded
+[@decrypt_errors.empty?, @decrypted_values.size]
+#=> [true, 25]
+
+
+## Rapid sequential manager access per thread
+barrier = Concurrent::CyclicBarrier.new(20)
+access_counts = Concurrent::Array.new
+
+threads = 20.times.map do
+  Thread.new do
+    barrier.wait
+    count = 0
+    50.times do
+      Familia::Encryption.manager(algorithm: nil)
+      count += 1
+    end
+    access_counts << count
+  end
+end
+
+threads.each(&:join)
+
+# Each thread completed 50 accesses
+access_counts.all? { |c| c == 50 }
+#=> true
+
+# Cleanup
+Familia.config.encryption_keys = nil
+Familia.config.current_key_version = nil