familia 2.0.0.pre19 → 2.0.0.pre22

data/try/thread_safety/field_registration_race_try.rb

@@ -0,0 +1,222 @@
+# try/thread_safety/field_registration_race_try.rb
+#
+# frozen_string_literal: true
+
+require_relative '../support/helpers/test_helpers'
+
+# Thread safety tests for field registration and collections
+#
+# Tests concurrent field definition to ensure that lazy initialization
+# of @fields, @field_types, and @field_groups collections doesn't result
+# in corruption or missing field definitions.
+#
+# These tests verify:
+# 1. Concurrent field definitions on same class
+# 2. Concurrent field group registrations
+# 3. Concurrent DataType field registrations (list, set, zset, hashkey)
+# 4. Field inheritance during concurrent subclass creation
+
+## Concurrent field definitions on same class
+class ConcurrentFieldModel < Familia::Horreum
+  identifier_field :test_id
+  field :test_id
+
+  def init
+    @test_id ||= SecureRandom.hex(4)
+  end
+end
+
+barrier = Concurrent::CyclicBarrier.new(50)
+field_names = Concurrent::Array.new
+
+threads = 50.times.map do |i|
+  Thread.new do
+    barrier.wait
+    field_name = "field_#{i}".to_sym
+    ConcurrentFieldModel.field(field_name)
+    field_names << field_name
+  end
+end
+
+threads.each(&:join)
+field_names.size
+#=> 50
+
+## Concurrent field group registrations
+class GroupedFieldModel < Familia::Horreum
+  identifier_field :test_id
+  field :test_id
+
+  def init
+    @test_id ||= SecureRandom.hex(4)
+  end
+end
+
+barrier = Concurrent::CyclicBarrier.new(20)
+groups = Concurrent::Array.new
+
+threads = 20.times.map do |i|
+  Thread.new do
+    barrier.wait
+    field_name = "field_#{i}".to_sym
+    GroupedFieldModel.field(field_name)
+    groups << field_name
+  end
+end
+
+threads.each(&:join)
+groups.size
+#=> 20
+
+## Concurrent DataType field registrations (list, set, zset, hashkey)
+class DataTypeFieldModel < Familia::Horreum
+  identifier_field :test_id
+  field :test_id
+
+  def init
+    @test_id ||= SecureRandom.hex(4)
+  end
+end
+
+barrier = Concurrent::CyclicBarrier.new(40)
+datatypes = Concurrent::Array.new
+
+threads = 40.times.map do |i|
+  Thread.new do
+    barrier.wait
+    case i % 4
+    when 0
+      DataTypeFieldModel.list("list_#{i}".to_sym)
+      datatypes << :list
+    when 1
+      DataTypeFieldModel.set("set_#{i}".to_sym)
+      datatypes << :set
+    when 2
+      DataTypeFieldModel.zset("zset_#{i}".to_sym)
+      datatypes << :zset
+    when 3
+      DataTypeFieldModel.hashkey("hash_#{i}".to_sym)
+      datatypes << :hashkey
+    end
+  end
+end
+
+threads.each(&:join)
+datatypes.count(:list)
+#=> 10
+
+## Field type tracking during concurrent registration
+class TypeTrackedModel < Familia::Horreum
+  identifier_field :test_id
+  field :test_id
+
+  def init
+    @test_id ||= SecureRandom.hex(4)
+  end
+end
+
+barrier = Concurrent::CyclicBarrier.new(30)
+field_types = Concurrent::Array.new
+
+threads = 30.times.map do |i|
+  Thread.new do
+    barrier.wait
+    field_name = "typed_field_#{i}".to_sym
+    TypeTrackedModel.field(field_name)
+    field_types << TypeTrackedModel.field_types[field_name]
+  end
+end
+
+threads.each(&:join)
+field_types.size
+#=> 30
+
+## Concurrent field definitions with default values
+class DefaultValueModel < Familia::Horreum
+  identifier_field :test_id
+  field :test_id
+
+  def init
+    @test_id ||= SecureRandom.hex(4)
+  end
+end
+
+barrier = Concurrent::CyclicBarrier.new(25)
+defaults = Concurrent::Array.new
+
+threads = 25.times.map do |i|
+  Thread.new do
+    barrier.wait
+    field_name = "default_field_#{i}".to_sym
+    DefaultValueModel.field(field_name)
+    defaults << field_name
+  end
+end
+
+threads.each(&:join)
+defaults.size
+#=> 25
+
+## Field registration during object instantiation
+class InstantiationModel < Familia::Horreum
+  identifier_field :test_id
+  field :test_id
+
+  def init
+    @test_id ||= SecureRandom.hex(4)
+  end
+  field :name
+  field :value
+end
+
+barrier = Concurrent::CyclicBarrier.new(30)
+instances = Concurrent::Array.new
+
+threads = 30.times.map do |i|
+  Thread.new do
+    barrier.wait
+    obj = InstantiationModel.new(name: "obj_#{i}", value: i)
+    instances << obj.name
+  end
+end
+
+threads.each(&:join)
+instances.size
+#=> 30
+
+## Concurrent class-level DataType registrations
+class ClassDataTypeModel < Familia::Horreum
+  identifier_field :test_id
+  field :test_id
+
+  def init
+    @test_id ||= SecureRandom.hex(4)
+  end
+end
+
+barrier = Concurrent::CyclicBarrier.new(20)
+class_types = Concurrent::Array.new
+
+threads = 20.times.map do |i|
+  Thread.new do
+    barrier.wait
+    case i % 4
+    when 0
+      ClassDataTypeModel.class_list("class_list_#{i}".to_sym)
+      class_types << :class_list
+    when 1
+      ClassDataTypeModel.class_set("class_set_#{i}".to_sym)
+      class_types << :class_set
+    when 2
+      ClassDataTypeModel.class_zset("class_zset_#{i}".to_sym)
+      class_types << :class_zset
+    when 3
+      ClassDataTypeModel.class_hashkey("class_hash_#{i}".to_sym)
+      class_types << :class_hashkey
+    end
+  end
+end
+
+threads.each(&:join)
+class_types.count(:class_list)
+#=> 5

data/try/thread_safety/logger_initialization_race_try.rb

@@ -0,0 +1,170 @@
+#
+# frozen_string_literal: true
+
+require_relative '../support/helpers/test_helpers'
+
+# Thread safety tests for logger lazy initialization
+#
+# Tests concurrent logger access to ensure that only a single logger
+# instance is created even under high concurrent load.
+#
+# These tests verify:
+# 1. Concurrent logger initialization (default logger)
+# 2. Logger singleton property
+# 3. Maximum contention with CyclicBarrier pattern
+# 4. Custom logger setter thread safety
+
+## Concurrent logger initialization with 50 threads
+# Reset the logger and mutex to simulate first access
+Familia.instance_variable_set(:@logger, nil)
+# Mutex is now initialized eagerly in Logging.extended hook
+
+barrier = Concurrent::CyclicBarrier.new(50)
+loggers = Concurrent::Array.new
+
+threads = 50.times.map do
+  Thread.new do
+    barrier.wait
+    # Get the logger instance
+    logger = Familia.logger
+    loggers << logger.object_id
+  end
+end
+
+threads.each(&:join)
+
+# All threads should get the same logger instance
+[loggers.any?(nil), loggers.uniq.size, loggers.size]
+#=> [false, 1, 50]
+
+
+## Logger is instance of FamiliaLogger
+Familia.instance_variable_set(:@logger, nil)
+# Mutex is now initialized eagerly in Logging.extended hook
+
+logger = Familia.logger
+logger.class.name
+#=> 'Familia::FamiliaLogger'
+
+
+## Logger has correct progname set
+Familia.instance_variable_set(:@logger, nil)
+# Mutex is now initialized eagerly in Logging.extended hook
+
+logger = Familia.logger
+logger.progname
+#=> 'Familia'
+
+
+## Logger has correct formatter set
+Familia.instance_variable_set(:@logger, nil)
+# Mutex is now initialized eagerly in Logging.extended hook
+
+logger = Familia.logger
+logger.formatter.class.name
+#=> 'Familia::LogFormatter'
+
+
+## Maximum contention with concurrent logging operations
+# Reset logger and test actual logging under concurrent load
+Familia.instance_variable_set(:@logger, nil)
+# Mutex is now initialized eagerly in Logging.extended hook
+
+barrier = Concurrent::CyclicBarrier.new(50)
+logger_ids = Concurrent::Array.new
+errors = Concurrent::Array.new
+
+threads = 50.times.map do |i|
+  Thread.new do
+    begin
+      barrier.wait
+      # Each thread logs a message
+      logger = Familia.logger
+      logger_ids << logger.object_id
+
+      # Capture output to avoid cluttering test output
+      original_stderr = $stderr
+      $stderr = StringIO.new
+      logger.info "Thread #{i} logging"
+      $stderr = original_stderr
+    rescue => e
+      errors << e.message
+    end
+  end
+end
+
+threads.each(&:join)
+
+# All threads should use same logger instance and have no errors
+[logger_ids.uniq.size, errors.empty?]
+#=> [1, true]
+
+
+## Custom logger setter clears atomic reference
+# Set a custom logger
+custom_logger = Logger.new($stderr)
+custom_logger.progname = 'CustomApp'
+
+Familia.logger = custom_logger
+
+# Getting logger should return the custom one
+retrieved_logger = Familia.logger
+[retrieved_logger.object_id == custom_logger.object_id, retrieved_logger.progname]
+#=> [true, 'CustomApp']
+
+
+## Setting logger multiple times is thread-safe
+# Reset to default logger first
+Familia.instance_variable_set(:@logger, nil)
+# Mutex is now initialized eagerly in Logging.extended hook
+Familia.logger  # Initialize default
+
+barrier = Concurrent::CyclicBarrier.new(20)
+final_loggers = Concurrent::Array.new
+
+threads = 20.times.map do |i|
+  Thread.new do
+    barrier.wait
+    # Half threads set new logger, half read
+    if i.even?
+      custom = Logger.new($stderr)
+      custom.progname = "Thread#{i}"
+      Familia.logger = custom
+    else
+      final_loggers << Familia.logger.object_id
+    end
+  end
+end
+
+threads.each(&:join)
+
+# After concurrent setter/getter operations, logger should still be valid
+final_logger = Familia.logger
+final_logger.class
+#=> Logger
+
+
+## Rapid sequential access maintains singleton
+Familia.instance_variable_set(:@logger, nil)
+# Mutex is now initialized eagerly in Logging.extended hook
+
+logger_ids = []
+100.times do
+  logger_ids << Familia.logger.object_id
+end
+
+logger_ids.uniq.size
+#=> 1
+
+
+## Mutex is used for thread safety
+Familia.instance_variable_set(:@logger, nil)
+# Mutex is now initialized eagerly in Logging.extended hook
+
+# Trigger lazy initialization
+Familia.logger
+
+# Should have created a Mutex for synchronization
+mutex = Familia.instance_variable_get(:@logger_mutex)
+mutex.class.name
+#=> 'Thread::Mutex'

data/try/thread_safety/middleware_registration_race_try.rb

@@ -0,0 +1,154 @@
+# try/thread_safety/middleware_registration_race_try.rb
+#
+# frozen_string_literal: true
+
+require_relative '../support/helpers/test_helpers'
+
+# Thread safety tests for middleware registration
+#
+# Tests concurrent middleware registration to ensure that race conditions
+# in the check-then-act pattern don't result in duplicate middleware
+# registration or corrupted middleware chains.
+#
+# These tests verify:
+# 1. Concurrent reconnect with middleware enabled
+# 2. Concurrent middleware version increment atomicity
+# 3. Middleware state consistency under concurrent access
+
+@original_logger_flag = nil
+@original_counter_flag = nil
+@original_middleware_registered = nil
+@original_logger_enabled = nil
+@original_counter_enabled = nil
+
+# Setup: Store original middleware state
+@original_logger_flag = Familia.instance_variable_get(:@logger_registered)
+@original_counter_flag = Familia.instance_variable_get(:@counter_registered)
+@original_middleware_registered = Familia.instance_variable_get(:@middleware_registered)
+@original_logger_enabled = Familia.enable_database_logging
+@original_counter_enabled = Familia.enable_database_counter
+
+## Concurrent reconnect calls with middleware enabled
+Familia.enable_database_logging = true
+Familia.enable_database_counter = true
+barrier = Concurrent::CyclicBarrier.new(20)
+results = Concurrent::Array.new
+
+threads = 20.times.map do
+  Thread.new do
+    barrier.wait
+    Familia.reconnect!
+    results << Familia.instance_variable_get(:@middleware_registered)
+  end
+end
+
+threads.each(&:join)
+results.size
+#=> 20
+
+## Concurrent middleware version increments preserve all updates
+initial_version = Familia.middleware_version
+barrier = Concurrent::CyclicBarrier.new(100)
+
+threads = 100.times.map do
+  Thread.new do
+    barrier.wait
+    Familia.increment_middleware_version!
+  end
+end
+
+threads.each(&:join)
+Familia.middleware_version - initial_version
+#=> 100
+
+## Concurrent reconnect and version check
+Familia.enable_database_logging = true
+barrier = Concurrent::CyclicBarrier.new(15)
+versions = Concurrent::Array.new
+
+threads = 15.times.map do |i|
+  Thread.new do
+    barrier.wait
+    if i < 5
+      Familia.reconnect!
+    end
+    versions << Familia.middleware_version
+  end
+end
+
+threads.each(&:join)
+versions.size
+#=> 15
+
+## Concurrent middleware state reads during reconnects
+barrier = Concurrent::CyclicBarrier.new(30)
+state_reads = Concurrent::Array.new
+
+threads = 30.times.map do |i|
+  Thread.new do
+    barrier.wait
+    if i < 10
+      Familia.reconnect!
+    end
+    state_reads << [
+      Familia.instance_variable_get(:@logger_registered),
+      Familia.instance_variable_get(:@counter_registered)
+    ]
+  end
+end
+
+threads.each(&:join)
+state_reads.size
+#=> 30
+
+## 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
+
+## Concurrent middleware enable/disable during reconnect
+Familia.enable_database_logging = false
+Familia.enable_database_counter = false
+barrier = Concurrent::CyclicBarrier.new(25)
+enable_results = Concurrent::Array.new
+
+threads = 25.times.map do |i|
+  Thread.new do
+    barrier.wait
+    case i % 3
+    when 0
+      Familia.enable_database_logging = true
+    when 1
+      Familia.enable_database_counter = true
+    when 2
+      Familia.reconnect!
+    end
+    enable_results << :completed
+  end
+end
+
+threads.each(&:join)
+enable_results.size
+#=> 25
+
+# Teardown: Restore original middleware state
+Familia.instance_variable_set(:@logger_registered, @original_logger_flag)
+Familia.instance_variable_set(:@counter_registered, @original_counter_flag)
+Familia.instance_variable_set(:@middleware_registered, @original_middleware_registered)
+Familia.enable_database_logging = @original_logger_enabled
+Familia.enable_database_counter = @original_counter_enabled

data/try/thread_safety/module_config_race_try.rb

@@ -0,0 +1,175 @@
+# try/thread_safety/module_config_race_try.rb
+#
+# frozen_string_literal: true
+
+require_relative '../support/helpers/test_helpers'
+
+# Thread safety tests for module-level configuration state
+#
+# Tests concurrent modification of Familia module configuration to ensure
+# that race conditions don't cause inconsistent behavior or invalid state.
+#
+# These tests verify:
+# 1. Concurrent URI configuration changes
+# 2. Concurrent prefix/suffix configuration
+# 3. Concurrent delimiter configuration during key generation
+# 4. Configuration consistency across threads
+
+@original_uri = nil
+@original_prefix = nil
+@original_suffix = nil
+@original_delim = nil
+
+# Setup: Store original configuration
+@original_uri = Familia.uri
+@original_prefix = Familia.prefix
+@original_suffix = Familia.suffix
+@original_delim = Familia.delim
+
+## Concurrent URI configuration changes result in valid state
+barrier = Concurrent::CyclicBarrier.new(20)
+uris = Concurrent::Array.new
+
+threads = 20.times.map do |i|
+  Thread.new do
+    barrier.wait
+    new_uri = "redis://localhost:#{6379 + i}"
+    Familia.uri = new_uri
+    uris << Familia.uri.to_s
+  end
+end
+
+threads.each(&:join)
+uris.size
+#=> 20
+
+## Concurrent prefix configuration maintains valid state
+Familia.prefix = nil
+barrier = Concurrent::CyclicBarrier.new(30)
+prefixes = Concurrent::Array.new
+
+threads = 30.times.map do |i|
+  Thread.new do
+    barrier.wait
+    Familia.prefix = "prefix_#{i}"
+    prefixes << Familia.prefix
+  end
+end
+
+threads.each(&:join)
+prefixes.size
+#=> 30
+
+## Concurrent suffix configuration maintains valid state
+Familia.suffix = :object
+barrier = Concurrent::CyclicBarrier.new(30)
+suffixes = Concurrent::Array.new
+
+threads = 30.times.map do |i|
+  Thread.new do
+    barrier.wait
+    Familia.suffix = "suffix_#{i}".to_sym
+    suffixes << Familia.suffix
+  end
+end
+
+threads.each(&:join)
+suffixes.size
+#=> 30
+
+## Concurrent delimiter configuration during key generation
+class DelimiterTestModel < Familia::Horreum
+  identifier_field :test_id
+  field :test_id
+  field :value
+end
+
+Familia.delim = ':'
+barrier = Concurrent::CyclicBarrier.new(30)
+keys = Concurrent::Array.new
+
+threads = 30.times.map do |i|
+  Thread.new do
+    barrier.wait
+    if i % 3 == 0
+      Familia.delim = '::'
+    end
+    obj = DelimiterTestModel.new(test_id: "id_#{i}", value: "test")
+    keys << obj.dbkey
+  end
+end
+
+threads.each(&:join)
+keys.size
+#=> 30
+
+## Concurrent prefix and suffix changes together
+Familia.prefix = nil
+Familia.suffix = :object
+barrier = Concurrent::CyclicBarrier.new(50)
+configs = Concurrent::Array.new
+
+threads = 50.times.map do |i|
+  Thread.new do
+    barrier.wait
+    if i.even?
+      Familia.prefix = "prefix_#{i}"
+    else
+      Familia.suffix = "suffix_#{i}"
+    end
+    configs << [Familia.prefix, Familia.suffix]
+  end
+end
+
+threads.each(&:join)
+configs.size
+#=> 50
+
+## Configuration reads during concurrent writes are consistent
+Familia.prefix = 'test'
+barrier = Concurrent::CyclicBarrier.new(40)
+read_results = Concurrent::Array.new
+
+threads = 40.times.map do |i|
+  Thread.new do
+    barrier.wait
+    if i < 5
+      # A few threads write
+      Familia.prefix = "new_prefix_#{i}"
+    else
+      # Most threads read
+      read_results << Familia.prefix
+    end
+  end
+end
+
+threads.each(&:join)
+read_results.size
+#=> 35
+
+## Concurrent URI and connection provider changes
+@original_provider = Familia.connection_provider
+barrier = Concurrent::CyclicBarrier.new(20)
+results = Concurrent::Array.new
+
+threads = 20.times.map do |i|
+  Thread.new do
+    barrier.wait
+    if i.even?
+      Familia.uri = "redis://localhost:#{6379 + i}"
+    else
+      results << Familia.uri.to_s
+    end
+  end
+end
+
+threads.each(&:join)
+results.size
+#=> 10
+
+# Teardown: Restore original configuration
+Familia.connection_provider = @original_provider
+Familia.uri = @original_uri
+Familia.prefix = @original_prefix
+Familia.suffix = @original_suffix
+Familia.delim = @original_delim