familia 2.0.0.pre19 → 2.0.0.pre22

data/try/thread_safety/feature_registry_race_try.rb

@@ -0,0 +1,226 @@
+# try/thread_safety/feature_registry_race_try.rb
+#
+# frozen_string_literal: true
+
+require_relative '../support/helpers/test_helpers'
+
+# Thread safety tests for feature registry initialization
+#
+# Tests concurrent feature registration to ensure that lazy initialization
+# of @features_available and @feature_definitions doesn't result in
+# corruption or missing feature registrations.
+#
+# These tests verify:
+# 1. Concurrent feature registration on same class
+# 2. Feature dependency resolution during concurrent registration
+# 3. Feature metadata consistency
+# 4. Feature activation during concurrent access
+
+## Concurrent feature registration on same class
+module TestFeature1; end
+module TestFeature2; end
+module TestFeature3; end
+
+class FeatureTestModel1 < Familia::Horreum
+  identifier_field :test_id
+  field :test_id
+
+  def init
+    @test_id ||= SecureRandom.hex(4)
+  end
+end
+
+FeatureTestModel1.instance_variable_set(:@features_available, nil)
+FeatureTestModel1.instance_variable_set(:@feature_definitions, nil)
+
+barrier = Concurrent::CyclicBarrier.new(20)
+features = Concurrent::Array.new
+
+threads = 20.times.map do |i|
+  Thread.new do
+    barrier.wait
+    feature_module = Module.new
+    feature_name = "test_feature_#{i}".to_sym
+    FeatureTestModel1.add_feature(feature_module, feature_name)
+    features << feature_name
+  end
+end
+
+threads.each(&:join)
+
+[features.size, FeatureTestModel1.features_available.is_a?(Hash)]
+#=> [20, true]
+
+## Feature activation during concurrent declaration
+class FeatureTestModel2 < Familia::Horreum
+  identifier_field :test_id
+  field :test_id
+
+  def init
+    @test_id ||= SecureRandom.hex(4)
+  end
+end
+
+barrier = Concurrent::CyclicBarrier.new(15)
+activated = Concurrent::Array.new
+
+threads = 15.times.map do |i|
+  Thread.new do
+    barrier.wait
+    feature_name = "activated_feature_#{i}".to_sym
+    feature_module = Module.new
+    FeatureTestModel2.add_feature(feature_module, feature_name)
+    FeatureTestModel2.feature(feature_name)
+    activated << feature_name
+  end
+end
+
+threads.each(&:join)
+activated.size
+#=> 15
+
+## Concurrent feature registration with field groups
+class FeatureFieldGroupModel < Familia::Horreum
+  identifier_field :test_id
+  field :test_id
+
+  def init
+    @test_id ||= SecureRandom.hex(4)
+  end
+end
+
+barrier = Concurrent::CyclicBarrier.new(20)
+feature_groups = Concurrent::Array.new
+
+threads = 20.times.map do |i|
+  Thread.new do
+    barrier.wait
+    feature_module = Module.new
+    feature_name = "grouped_feature_#{i}".to_sym
+    field_group = "group_#{i}".to_sym
+    FeatureFieldGroupModel.add_feature(feature_module, feature_name, field_group: field_group)
+    feature_groups << field_group
+  end
+end
+
+threads.each(&:join)
+feature_groups.size
+#=> 20
+
+## Feature dependency registration during concurrent access
+class DependencyTestModel < Familia::Horreum
+  identifier_field :test_id
+  field :test_id
+
+  def init
+    @test_id ||= SecureRandom.hex(4)
+  end
+end
+
+barrier = Concurrent::CyclicBarrier.new(25)
+dependencies = Concurrent::Array.new
+
+threads = 25.times.map do |i|
+  Thread.new do
+    barrier.wait
+    feature_module = Module.new
+    feature_name = "dependent_feature_#{i}".to_sym
+    depends_on = i > 0 ? ["dependent_feature_#{i - 1}".to_sym] : []
+    DependencyTestModel.add_feature(feature_module, feature_name, depends_on: depends_on)
+    dependencies << feature_name
+  end
+end
+
+threads.each(&:join)
+dependencies.size
+#=> 25
+
+## Concurrent feature queries
+class QueryTestModel < Familia::Horreum
+  identifier_field :test_id
+  field :test_id
+
+  def init
+    @test_id ||= SecureRandom.hex(4)
+  end
+end
+
+# Pre-register some features
+5.times do |i|
+  QueryTestModel.add_feature(Module.new, "query_feature_#{i}".to_sym)
+end
+
+barrier = Concurrent::CyclicBarrier.new(30)
+query_results = Concurrent::Array.new
+
+threads = 30.times.map do
+  Thread.new do
+    barrier.wait
+    available = QueryTestModel.features_available
+    query_results << available.keys.size
+  end
+end
+
+threads.each(&:join)
+query_results.size
+#=> 30
+
+
+## Feature metadata consistency during concurrent registration
+class MetadataTestModel < Familia::Horreum
+  identifier_field :test_id
+  field :test_id
+
+  def init
+    @test_id ||= SecureRandom.hex(4)
+  end
+end
+
+barrier = Concurrent::CyclicBarrier.new(20)
+metadata = Concurrent::Array.new
+
+threads = 20.times.map do |i|
+  Thread.new do
+    barrier.wait
+    feature_module = Module.new do
+      def self.feature_name
+        "metadata_feature"
+      end
+    end
+    feature_name = "meta_feature_#{i}".to_sym
+    MetadataTestModel.add_feature(feature_module, feature_name)
+    metadata << [feature_name, MetadataTestModel.features_available[feature_name]]
+  end
+end
+
+threads.each(&:join)
+metadata.size
+#=> 20
+
+
+## Feature definitions hash consistency
+class DefinitionsTestModel < Familia::Horreum
+  identifier_field :test_id
+  field :test_id
+
+  def init
+    @test_id ||= SecureRandom.hex(4)
+  end
+end
+
+barrier = Concurrent::CyclicBarrier.new(30)
+definitions = Concurrent::Array.new
+
+threads = 30.times.map do |i|
+  Thread.new do
+    barrier.wait
+    feature_module = Module.new
+    feature_name = "def_feature_#{i}".to_sym
+    DefinitionsTestModel.add_feature(feature_module, feature_name)
+    definitions << DefinitionsTestModel.feature_definitions.keys.size
+  end
+end
+
+threads.each(&:join)
+definitions.size
+#=> 30

data/try/thread_safety/fiber_pipeline_isolation_try.rb

@@ -0,0 +1,235 @@
+# try/thread_safety/fiber_pipeline_isolation_try.rb
+#
+# frozen_string_literal: true
+
+require_relative '../support/helpers/test_helpers'
+
+# Thread safety tests for fiber-local pipeline storage
+#
+# Tests that fiber-local pipeline storage properly isolates pipelines
+# between different fibers and threads, ensuring no cross-contamination.
+#
+# These tests verify:
+# 1. Concurrent pipelines in different fibers are isolated
+# 2. Pipeline context doesn't leak between fibers
+# 3. Nested pipelines work correctly across fibers
+# 4. Pipeline cleanup happens properly per fiber
+
+## Concurrent threads with isolated pipelines
+results = Concurrent::Array.new
+barrier = Concurrent::CyclicBarrier.new(10)
+
+# Each thread has its own root fiber, so pipelines are isolated per-thread
+threads = 10.times.map do |i|
+  Thread.new do
+    barrier.wait  # Synchronize start for maximum contention
+    Familia.pipeline do
+      # Each thread's fiber should have isolated pipeline context
+      conn = Fiber[:familia_pipeline]
+      # Use direct Redis commands instead of save
+      conn.set("test:pipe:#{i}", "value_#{i}")
+      results << [i, conn.object_id, "pipe_#{i}"]
+    end
+  end
+end
+
+threads.each(&:join)
+
+results
+#==> _.size == 10
+#==> _.map { |(i, _, _)| i }.sort == (0..9).to_a
+#==> _.map { |(_, _, pipe_id)| pipe_id }.uniq.size == 10
+
+## Pipeline isolation across multiple threads
+barrier = Concurrent::CyclicBarrier.new(15)
+fiber_results = Concurrent::Array.new
+
+# Each thread automatically has its own root fiber
+threads = 15.times.map do |i|
+  Thread.new do
+    barrier.wait
+    Familia.pipeline do
+      conn = Fiber[:familia_pipeline]
+      fiber_results << [Thread.current.object_id, conn.object_id]
+    end
+  end
+end
+
+threads.each(&:join)
+
+fiber_results
+#==> _.size == 15
+#==> _.map { |(thread_id, _)| thread_id }.uniq.size >= 10
+
+## Nested pipelines in same fiber maintain context
+nested_results = Concurrent::Array.new
+
+fiber = Fiber.new do
+  Familia.pipeline do
+    outer_conn = Fiber[:familia_pipeline]
+    nested_results << [:outer, outer_conn.object_id]
+
+    Familia.pipeline do
+      inner_conn = Fiber[:familia_pipeline]
+      nested_results << [:inner, inner_conn.object_id]
+    end
+
+    after_inner = Fiber[:familia_pipeline]
+    nested_results << [:after_inner, after_inner.object_id]
+  end
+
+  after_outer = Fiber[:familia_pipeline]
+  nested_results << [:after_outer, after_outer.nil?]
+end
+
+fiber.resume
+
+nested_results
+#==> _.size == 4
+#==> _[0][1] == _[1][1]  # Same connection for nested
+#==> _[0][1] == _[2][1]  # Same connection after inner
+#==> _[3][1] == true  # Cleaned up after outer
+
+## Pipeline context doesn't leak between sequential fibers
+sequential_results = Concurrent::Array.new
+
+5.times do |i|
+  fiber = Fiber.new do
+    Familia.pipeline do
+      conn = Fiber[:familia_pipeline]
+      sequential_results << [i, conn.object_id]
+    end
+  end
+  fiber.resume
+end
+
+sequential_results
+#==> _.size == 5
+#==> _.map { |(i, _)| i } == [0, 1, 2, 3, 4]
+
+## Concurrent fiber creation and pipeline execution
+creation_barrier = Concurrent::CyclicBarrier.new(20)
+execution_results = Concurrent::Array.new
+
+threads = 20.times.map do |i|
+  Thread.new do
+    creation_barrier.wait
+    fiber = Fiber.new do
+      begin
+        Familia.pipeline do
+          conn = Fiber[:familia_pipeline]
+          # Use direct Redis commands instead of save
+          conn.set("test:concurrent_pipe:#{i}", "value_#{i}")
+          execution_results << "concurrent_#{i}"
+        end
+      rescue => e
+        execution_results << [:error, e.class.name]
+      end
+    end
+    fiber.resume
+  end
+end
+
+threads.each(&:join)
+
+[execution_results.size, execution_results.count { |r| r.is_a?(String) && r.start_with?('concurrent_') }]
+#=> [20, 20]
+
+## Pipeline cleanup after exception
+exception_results = Concurrent::Array.new
+
+fiber = Fiber.new do
+  begin
+    Familia.pipeline do
+      exception_results << Fiber[:familia_pipeline].object_id
+      raise "Test exception"
+    end
+  rescue => e
+    exception_results << [:exception, e.message]
+  end
+  exception_results << [:after_exception, Fiber[:familia_pipeline].nil?]
+end
+
+fiber.resume
+
+exception_results
+#==> _.size == 3
+#==> _[0].is_a?(Integer)
+#==> _[1] == [:exception, "Test exception"]
+#==> _[2] == [:after_exception, true]
+
+## Fiber switching during pipeline maintains context
+switch_results = Concurrent::Array.new
+
+fiber1 = Fiber.new do
+  Familia.pipeline do
+    conn1 = Fiber[:familia_pipeline]
+    switch_results << [:fiber1_before_yield, conn1.object_id]
+    Fiber.yield
+    conn1_after = Fiber[:familia_pipeline]
+    switch_results << [:fiber1_after_yield, conn1_after.object_id]
+  end
+end
+
+fiber2 = Fiber.new do
+  Familia.pipeline do
+    conn2 = Fiber[:familia_pipeline]
+    switch_results << [:fiber2, conn2.object_id]
+  end
+end
+
+fiber1.resume
+fiber2.resume
+fiber1.resume
+
+switch_results
+#==> _.size == 3
+#==> _[0][1] == _[2][1]  # Same connection before/after yield
+#==> _[0][1] != _[1][1]  # Different connections per fiber
+
+## Multiple pipelines per fiber (sequential)
+multi_pipe_results = Concurrent::Array.new
+
+fiber = Fiber.new do
+  3.times do |i|
+    Familia.pipeline do
+      conn = Fiber[:familia_pipeline]
+      multi_pipe_results << [i, conn.object_id]
+    end
+    multi_pipe_results << [:between, Fiber[:familia_pipeline].nil?]
+  end
+end
+
+fiber.resume
+
+multi_pipe_results
+#==> _.size == 6
+#==> _.select { |(label, _)| label == :between }.all? { |(_, is_nil)| is_nil }
+
+## Pipeline and transaction isolation in same fiber
+mixed_results = Concurrent::Array.new
+
+fiber = Fiber.new do
+  Familia.pipeline do
+    pipe_conn = Fiber[:familia_pipeline]
+    mixed_results << [:pipeline, pipe_conn.object_id]
+
+    Familia.transaction do
+      txn_conn = Fiber[:familia_transaction]
+      pipe_during_txn = Fiber[:familia_pipeline]
+      mixed_results << [:transaction, txn_conn.object_id]
+      mixed_results << [:pipeline_during_txn, pipe_during_txn.object_id]
+    end
+
+    pipe_after_txn = Fiber[:familia_pipeline]
+    mixed_results << [:pipeline_after_txn, pipe_after_txn.object_id]
+  end
+end
+
+fiber.resume
+
+mixed_results
+#==> _.size == 4
+#==> _[0][1] == _[2][1]  # Pipeline preserved during transaction
+#==> _[0][1] == _[3][1]  # Pipeline preserved after transaction
+#==> _[0][1] != _[1][1]  # Different connections for pipeline and transaction

data/try/thread_safety/fiber_transaction_isolation_try.rb

@@ -0,0 +1,208 @@
+# try/thread_safety/fiber_transaction_isolation_try.rb
+#
+# frozen_string_literal: true
+
+require_relative '../support/helpers/test_helpers'
+
+# Thread safety tests for fiber-local transaction storage
+#
+# Tests that fiber-local transaction storage properly isolates transactions
+# between different fibers and threads, ensuring no cross-contamination.
+#
+# These tests verify:
+# 1. Concurrent transactions in different fibers are isolated
+# 2. Transaction context doesn't leak between fibers
+# 3. Nested transactions work correctly across fibers
+# 4. Transaction cleanup happens properly per fiber
+
+## Concurrent threads with isolated transactions
+results = Concurrent::Array.new
+barrier = Concurrent::CyclicBarrier.new(10)
+
+# Each thread has its own root fiber, so transactions are isolated per-thread
+threads = 10.times.map do |i|
+  Thread.new do
+    barrier.wait  # Synchronize start for maximum contention
+    Familia.transaction do
+      # Each thread's fiber should have isolated transaction context
+      conn = Fiber[:familia_transaction]
+      # Use direct Redis commands instead of save (which is not allowed in transactions)
+      conn.set("test:txn:#{i}", "value_#{i}")
+      results << [i, conn.object_id, "txn_#{i}"]
+    end
+  end
+end
+
+threads.each(&:join)
+
+results
+#==> _.size == 10
+#==> _.map { |(i, _, _)| i }.sort == (0..9).to_a
+#==> _.map { |(_, _, txn_id)| txn_id }.uniq.size == 10
+
+## Transaction isolation across multiple threads
+barrier = Concurrent::CyclicBarrier.new(15)
+fiber_results = Concurrent::Array.new
+
+# Each thread automatically has its own root fiber
+threads = 15.times.map do |i|
+  Thread.new do
+    barrier.wait
+    Familia.transaction do
+      conn = Fiber[:familia_transaction]
+      fiber_results << [Thread.current.object_id, conn.object_id]
+    end
+  end
+end
+
+threads.each(&:join)
+
+fiber_results
+#==> _.size == 15
+#==> _.map { |(thread_id, _)| thread_id }.uniq.size >= 10
+
+## Nested transactions in same fiber maintain context
+nested_results = Concurrent::Array.new
+
+fiber = Fiber.new do
+  Familia.transaction do
+    outer_conn = Fiber[:familia_transaction]
+    nested_results << [:outer, outer_conn.object_id]
+
+    Familia.transaction do
+      inner_conn = Fiber[:familia_transaction]
+      nested_results << [:inner, inner_conn.object_id]
+    end
+
+    after_inner = Fiber[:familia_transaction]
+    nested_results << [:after_inner, after_inner.object_id]
+  end
+
+  after_outer = Fiber[:familia_transaction]
+  nested_results << [:after_outer, after_outer.nil?]
+end
+
+fiber.resume
+
+nested_results
+#==> _.size == 4
+#==> _[0][1] == _[1][1]  # Same connection for nested
+#==> _[0][1] == _[2][1]  # Same connection after inner
+#==> _[3][1] == true  # Cleaned up after outer
+
+## Transaction context doesn't leak between sequential fibers
+sequential_results = Concurrent::Array.new
+
+5.times do |i|
+  fiber = Fiber.new do
+    Familia.transaction do
+      conn = Fiber[:familia_transaction]
+      sequential_results << [i, conn.object_id]
+    end
+  end
+  fiber.resume
+end
+
+sequential_results
+#==> _.size == 5
+#==> _.map { |(i, _)| i } == [0, 1, 2, 3, 4]
+
+## Concurrent fiber creation and transaction execution
+creation_barrier = Concurrent::CyclicBarrier.new(20)
+execution_results = Concurrent::Array.new
+
+threads = 20.times.map do |i|
+  Thread.new do
+    creation_barrier.wait
+    fiber = Fiber.new do
+      begin
+        Familia.transaction do
+          # Use direct Redis commands instead of save
+          conn = Fiber[:familia_transaction]
+          conn.set("test:concurrent:#{i}", "value_#{i}")
+          execution_results << "concurrent_#{i}"
+        end
+      rescue => e
+        execution_results << [:error, e.class.name]
+      end
+    end
+    fiber.resume
+  end
+end
+
+threads.each(&:join)
+
+execution_results
+#==> _.size == 20
+#==> _.all? { |r| r.is_a?(String) && r.start_with?('concurrent_') }
+#==> true
+
+## Transaction cleanup after exception
+exception_results = Concurrent::Array.new
+
+fiber = Fiber.new do
+  begin
+    Familia.transaction do
+      exception_results << Fiber[:familia_transaction].object_id
+      raise "Test exception"
+    end
+  rescue => e
+    exception_results << [:exception, e.message]
+  end
+  exception_results << [:after_exception, Fiber[:familia_transaction].nil?]
+end
+
+fiber.resume
+exception_results
+#==> _.size == 3
+#==> _[0].is_a?(Integer)
+#==> _[1] == [:exception, "Test exception"]
+#==> _[2] == [:after_exception, true]
+
+## Fiber switching during transaction maintains context
+switch_results = Concurrent::Array.new
+
+fiber1 = Fiber.new do
+  Familia.transaction do
+    conn1 = Fiber[:familia_transaction]
+    switch_results << [:fiber1_before_yield, conn1.object_id]
+    Fiber.yield
+    conn1_after = Fiber[:familia_transaction]
+    switch_results << [:fiber1_after_yield, conn1_after.object_id]
+  end
+end
+
+fiber2 = Fiber.new do
+  Familia.transaction do
+    conn2 = Fiber[:familia_transaction]
+    switch_results << [:fiber2, conn2.object_id]
+  end
+end
+
+fiber1.resume
+fiber2.resume
+fiber1.resume
+
+switch_results
+#==> _.size == 3
+#==> _[0][1] == _[2][1]  # Same connection before/after yield
+#==> _[0][1] != _[1][1]  # Different connections per fiber
+
+## Multiple transactions per fiber (sequential)
+multi_txn_results = Concurrent::Array.new
+
+fiber = Fiber.new do
+  3.times do |i|
+    Familia.transaction do
+      conn = Fiber[:familia_transaction]
+      multi_txn_results << [i, conn.object_id]
+    end
+    multi_txn_results << [:between, Fiber[:familia_transaction].nil?]
+  end
+end
+
+fiber.resume
+
+multi_txn_results
+#==> _.size == 6
+#==> _.select { |(label, _)| label == :between }.all? { |(_, is_nil)| is_nil }