familia 2.0.0.pre15 → 2.0.0.pre17

data/try/connection/pipeline_fallback_integration_try.rb

@@ -0,0 +1,128 @@
+#
+# Tests pipeline fallback modes when connection handlers don't support pipelines.
+# Validates that pipeline_mode configuration works correctly with cached connections
+# and that the fallback behavior matches transaction fallback patterns.
+#
+
+require_relative '../helpers/test_helpers'
+
+# Store original values
+$original_pipeline_mode = Familia.pipeline_mode
+$original_transaction_mode = Familia.transaction_mode
+
+# Test model for pipeline fallback scenarios
+class PipelineFallbackTest < Familia::Horreum
+  identifier_field :testid
+  field :testid
+end
+
+## Test 1: Strict mode raises error with cached connection
+Familia.configure { |c| c.pipeline_mode = :strict }
+
+# Cache connection at class level (uses DefaultConnectionHandler which doesn't support pipelines)
+PipelineFallbackTest.instance_variable_set(:@dbclient, Familia.create_dbclient)
+
+customer = PipelineFallbackTest.new(testid: 'strict_test')
+customer.pipelined { |c| c.set('key', 'value') }
+#=:> Familia::OperationModeError
+#=~> /Cannot start pipeline with.*CachedConnectionHandler/
+
+## Test 2: Warn mode falls back successfully with cached connection
+Familia.configure { |c| c.pipeline_mode = :warn }
+
+# Cache connection at class level
+PipelineFallbackTest.instance_variable_set(:@dbclient, Familia.create_dbclient)
+
+customer2 = PipelineFallbackTest.new(testid: 'warn_test')
+$warn_result = customer2.pipelined do |conn|
+  conn.set(customer2.dbkey('field1'), 'value1')
+  conn.set(customer2.dbkey('field2'), 'value2')
+  conn.get(customer2.dbkey('field1'))
+end
+$warn_result.successful?
+#=> true
+
+## Test 2b: Warn mode result contains all command results
+$warn_result.results.size
+#=> 3
+
+## Test 2c: Warn mode result contains correct value
+$warn_result.results[2]
+#=> 'value1'
+
+## Test 3: Fresh connections still support real pipelines in strict mode
+Familia.configure { |c| c.pipeline_mode = :strict }
+
+# Clear cached class-level connection to force CreateConnectionHandler
+PipelineFallbackTest.remove_instance_variable(:@dbclient) if PipelineFallbackTest.instance_variable_defined?(:@dbclient)
+
+customer3 = PipelineFallbackTest.new(testid: 'fresh_test')
+$fresh_result = customer3.pipelined do |conn|
+  conn.set('pipeline_key1', 'val1')
+  conn.set('pipeline_key2', 'val2')
+  conn.get('pipeline_key1')
+end
+$fresh_result.successful?
+#=> true
+
+## Test 3b: Real pipeline returns correct result count
+$fresh_result.results.size
+#=> 3
+
+## Test 4: MultiResult format is correct for fallback
+Familia.configure { |c| c.pipeline_mode = :permissive }
+
+# Cache connection at class level
+PipelineFallbackTest.instance_variable_set(:@dbclient, Familia.create_dbclient)
+
+customer4 = PipelineFallbackTest.new(testid: 'multiresult_test')
+$multi_result = customer4.pipelined do |conn|
+  conn.set(customer4.dbkey('test'), 'value')
+  conn.get(customer4.dbkey('test'))
+end
+$multi_result.class.name
+#=> 'MultiResult'
+
+## Test 4b: MultiResult successful? returns correct value
+$multi_result.successful?
+#=> true
+
+## Test 4c: MultiResult results is an Array
+$multi_result.results.class
+#=> Array
+
+## Test 5: Permissive mode silently falls back
+Familia.configure { |c| c.pipeline_mode = :permissive }
+
+# Cache connection at class level
+PipelineFallbackTest.instance_variable_set(:@dbclient, Familia.create_dbclient)
+
+customer5 = PipelineFallbackTest.new(testid: 'permissive_test')
+$permissive_result = customer5.pipelined do |conn|
+  conn.set(customer5.dbkey('counter'), '0')
+  conn.incr(customer5.dbkey('counter'))
+  conn.get(customer5.dbkey('counter'))
+end
+$permissive_result.successful?
+#=> true
+
+## Test 5b: Permissive mode result contains correct values
+$permissive_result.results
+#=> ['OK', 1, '1']
+
+## Test 6: Pipeline mode configuration validation
+Familia.configure { |c| c.pipeline_mode = :invalid }
+#=:> ArgumentError
+#=~> /Pipeline mode must be :strict, :warn, or :permissive/
+
+## Test 7: Default pipeline_mode is :warn
+Familia.instance_variable_set(:@pipeline_mode, nil)
+Familia.pipeline_mode
+#=> :warn
+
+## Cleanup: Restore original values
+Familia.configure do |c|
+  c.pipeline_mode = $original_pipeline_mode
+  c.transaction_mode = $original_transaction_mode
+end
+PipelineFallbackTest.remove_instance_variable(:@dbclient) if PipelineFallbackTest.instance_variable_defined?(:@dbclient)

data/try/connection/responsibility_chain_tracking_try.rb

@@ -0,0 +1,72 @@
+# ResponsibilityChain Handler Tracking Tryouts
+#
+# Tests that the ResponsibilityChain correctly tracks which handler provided
+# each connection by setting Fiber[:familia_connection_handler_class]. This enables
+# operation mode guards to enforce constraints based on connection source.
+#
+# The chain should:
+# - Try handlers in order until one returns a connection
+# - Set Fiber[:familia_connection_handler_class] to the successful handler's class
+# - Return the connection from the successful handler
+# - Return nil if no handler provides a connection
+
+require_relative '../helpers/test_helpers'
+
+# Setup - clear any existing fiber state
+Fiber[:familia_connection_handler_class] = nil
+Fiber[:familia_connection] = nil
+
+## Chain tracks CreateConnectionHandler for normal connections
+customer = Customer.new
+customer.custid = 'tracking_test'
+connection = customer.dbclient
+Fiber[:familia_connection_handler_class]
+#=> Familia::Connection::CreateConnectionHandler
+
+## Chain tracks FiberConnectionHandler for middleware connections
+begin
+  test_conn = Customer.create_dbclient
+  Fiber[:familia_connection] = [test_conn, Familia.middleware_version]
+
+  customer = Customer.new
+  customer.custid = 'fiber_test'
+  connection = customer.dbclient
+  Fiber[:familia_connection_handler_class]
+ensure
+  Fiber[:familia_connection] = nil
+  Fiber[:familia_connection_handler_class] = nil
+end
+#=> Familia::Connection::FiberConnectionHandler
+
+## Chain tracks ProviderConnectionHandler for connection providers
+original_provider = Familia.connection_provider
+begin
+  Familia.connection_provider = ->(uri) { Redis.new(url: uri) }
+
+  customer = Customer.new
+  customer.custid = 'provider_test'
+  connection = customer.dbclient
+  Fiber[:familia_connection_handler_class]
+ensure
+  Familia.connection_provider = original_provider
+  Fiber[:familia_connection_handler_class] = nil
+end
+#=> Familia::Connection::ProviderConnectionHandler
+
+## Chain returns nil when no handler provides connection
+# Create a mock chain with handlers that return nil
+chain = Familia::Connection::ResponsibilityChain.new
+chain.add_handler(Familia::Connection::FiberTransactionHandler.new)
+chain.add_handler(Familia::Connection::FiberConnectionHandler.new)
+
+result = chain.handle('test_uri')
+result.nil?
+#=> true
+
+## Chain sets handler class even when tracking connections
+customer = Customer.new
+customer.custid = 'final_test'
+conn = customer.dbclient
+handler_class = Fiber[:familia_connection_handler_class]
+handler_class == Familia::Connection::CreateConnectionHandler && !conn.nil?
+#=> true

data/try/connection/transaction_fallback_integration_try.rb

@@ -0,0 +1,288 @@
+# Transaction Fallback Integration Tryouts
+#
+# Tests real-world scenarios where transaction fallback is needed, particularly
+# focusing on save operations, relationship updates, and other high-level
+# operations that internally use transactions.
+#
+# These tests verify that the transaction mode configuration works seamlessly
+# with Familia's existing features when connection handlers don't support
+# transactions (e.g., cached connections, middleware connections).
+
+require_relative '../helpers/test_helpers'
+
+# Setup - store original values
+$original_transaction_mode = Familia.transaction_mode
+$original_provider = Familia.connection_provider
+
+# Create test classes for integration testing
+class IntegrationTestUser < Familia::Horreum
+  identifier_field :user_id
+  field :user_id
+  field :name
+  field :email
+  field :status
+  list :activity_log
+  set :tags
+  zset :scores
+end
+
+class IntegrationTestSession < Familia::Horreum
+  identifier_field :session_id
+  field :session_id
+  field :user_id
+  field :created_at
+  field :expires_at
+end
+
+## Save operation works with transaction fallback in warn mode
+begin
+  Familia.configure { |config| config.transaction_mode = :warn }
+
+  # Force CachedConnectionHandler
+  IntegrationTestUser.instance_variable_set(:@dbclient, Familia.create_dbclient)
+
+  user = IntegrationTestUser.new(
+    user_id: 'save_test_001',
+    name: 'Test User',
+    email: 'test@example.com',
+    status: 'active'
+  )
+
+  # Save internally uses transactions for atomicity
+  result = user.save
+
+  # Should complete successfully using individual commands
+  result && user.exists?
+ensure
+  IntegrationTestUser.remove_instance_variable(:@dbclient)
+  Familia.configure { |config| config.transaction_mode = :strict }
+end
+#=> true
+
+## Save operation works with transaction fallback in permissive mode
+begin
+  Familia.configure { |config| config.transaction_mode = :permissive }
+
+  # Force CachedConnectionHandler
+  IntegrationTestUser.instance_variable_set(:@dbclient, Familia.create_dbclient)
+
+  user = IntegrationTestUser.new(
+    user_id: 'save_test_002',
+    name: 'Permissive User',
+    email: 'permissive@example.com'
+  )
+
+  # Should save silently using individual commands
+  result = user.save
+
+  result && user.exists?
+ensure
+  IntegrationTestUser.remove_instance_variable(:@dbclient)
+  Familia.configure { |config| config.transaction_mode = :strict }
+end
+#=> true
+
+## Multiple field updates work with fallback
+begin
+  Familia.configure { |config| config.transaction_mode = :permissive }
+  IntegrationTestUser.instance_variable_set(:@dbclient, Familia.create_dbclient)
+
+  user = IntegrationTestUser.new(user_id: 'update_test_001')
+  user.save
+
+  # Update multiple fields - should use individual commands
+  user.name = 'Updated Name'
+  user.email = 'updated@example.com'
+  user.status = 'updated'
+
+  result = user.save
+
+  # Verify all fields were updated
+  reloaded_user = IntegrationTestUser.load('update_test_001')
+  result &&
+  reloaded_user.name == 'Updated Name' &&
+  reloaded_user.email == 'updated@example.com' &&
+  reloaded_user.status == 'updated'
+ensure
+  IntegrationTestUser.remove_instance_variable(:@dbclient)
+  Familia.configure { |config| config.transaction_mode = :strict }
+end
+#=> true
+
+## Data type operations work with transaction fallback
+
+Familia.configure { |config| config.transaction_mode = :permissive }
+IntegrationTestUser.instance_variable_set(:@dbclient, Familia.create_dbclient)
+
+user = IntegrationTestUser.new(user_id: 'datatype_test_001')
+user.transaction { |conn| conn.set('test', 'value') }
+
+# Test list operations
+user.activity_log.add('user_created')
+user.activity_log.add('profile_updated')
+
+# Test set operations
+user.tags.add('premium')
+user.tags.add('verified')
+
+# Test sorted set operations
+user.scores.add('game_score', 100)
+user.scores.add('quiz_score', 85)
+
+# Verify all operations worked
+results = [
+  user.activity_log.size,
+  user.tags.include?('premium'),
+  user.scores.score('game_score')
+]
+
+user.destroy!
+
+# Clean up test data
+IntegrationTestUser.remove_instance_variable(:@dbclient)
+Familia.configure { |config| config.transaction_mode = :strict }
+
+results
+#=> [2, true, 100.0]
+
+## Connection provider integration with transaction modes
+begin
+  Familia.configure { |config| config.transaction_mode = :warn }
+
+  # Set up connection provider that doesn't support transactions
+  test_connections = {}
+  Familia.connection_provider = lambda do |uri|
+    test_connections[uri] ||= Familia.create_dbclient(uri)
+  end
+
+  user = IntegrationTestUser.new(
+    user_id: 'provider_test_001',
+    name: 'Provider Test User'
+  )
+
+  # Should work with connection provider
+  result = user.save
+
+  result && user.exists?
+ensure
+  Familia.connection_provider = $original_provider
+  Familia.configure { |config| config.transaction_mode = :strict }
+end
+#=> true
+
+## Mixed connection handlers in same operation
+begin
+  Familia.configure { |config| config.transaction_mode = :permissive }
+
+  # User class with cached connection (fallback mode)
+  IntegrationTestUser.instance_variable_set(:@dbclient, Familia.create_dbclient)
+
+  # Session class without cached connection (normal mode)
+  user = IntegrationTestUser.new(user_id: 'mixed_test_001')
+  session = IntegrationTestSession.new(
+    session_id: 'sess_mixed_001',
+    user_id: 'mixed_test_001',
+    created_at: Time.now.to_i
+  )
+
+  # Both should save successfully despite different connection handlers
+  user_saved = user.save
+  session_saved = session.save
+
+  user_saved && session_saved && user.exists? && session.exists?
+ensure
+  IntegrationTestUser.remove_instance_variable(:@dbclient)
+  Familia.configure { |config| config.transaction_mode = :strict }
+end
+#=> true
+
+## Transaction mode changes during runtime
+begin
+  IntegrationTestUser.instance_variable_set(:@dbclient, Familia.create_dbclient)
+
+  user = IntegrationTestUser.new(user_id: 'runtime_test_001')
+
+  # Start in strict mode - should fail
+  Familia.configure { |config| config.transaction_mode = :strict }
+  strict_failed = false
+  begin
+    user.transaction { |conn| conn.set('test_key', 'test_value') }
+  rescue Familia::OperationModeError
+    strict_failed = true
+  end
+
+  # Switch to permissive mode - should work
+  Familia.configure { |config| config.transaction_mode = :permissive }
+  result = user.transaction { |conn| conn.set('test_key', 'test_value') }
+  permissive_worked = result.successful?
+
+  strict_failed && permissive_worked
+ensure
+  IntegrationTestUser.remove_instance_variable(:@dbclient)
+  Familia.configure { |config| config.transaction_mode = :strict }
+end
+#=> true
+
+## Large batch operations with transaction fallback
+begin
+  Familia.configure { |config| config.transaction_mode = :permissive }
+  IntegrationTestUser.instance_variable_set(:@dbclient, Familia.create_dbclient)
+
+  user = IntegrationTestUser.new(user_id: 'batch_test_001')
+
+  # Simulate a large batch operation that would normally use transactions
+  result = user.transaction do |conn|
+    # Add multiple activity log entries
+    (1..10).each do |i|
+      conn.rpush(user.activity_log.dbkey, "activity_#{i}")
+    end
+
+    # Add multiple tags
+    %w[tag1 tag2 tag3 tag4 tag5].each do |tag|
+      conn.sadd(user.tags.dbkey, tag)
+    end
+
+    # Add user fields
+    conn.hset(user.dbkey, 'batch_processed', 'true')
+  end
+
+  # Should complete successfully and return MultiResult
+  result.is_a?(MultiResult) && result.successful?
+ensure
+  IntegrationTestUser.remove_instance_variable(:@dbclient)
+  Familia.configure { |config| config.transaction_mode = :strict }
+end
+#=> true
+
+## Error handling in individual command mode
+begin
+  Familia.configure { |config| config.transaction_mode = :permissive }
+  IntegrationTestUser.instance_variable_set(:@dbclient, Familia.create_dbclient)
+
+  user = IntegrationTestUser.new(user_id: 'error_test_001')
+
+  # Execute commands where some might fail
+  result = user.transaction do |conn|
+    conn.hset(user.dbkey, 'field1', 'value1')  # Should succeed
+
+    # This might fail but shouldn't stop other commands
+    begin
+      conn.incr('non_numeric_key')  # Might fail if key exists as string
+    rescue => e
+      # Individual commands can handle their own errors
+    end
+
+    conn.hset(user.dbkey, 'field2', 'value2')  # Should succeed
+  end
+
+  # Should return MultiResult even with mixed success/failure
+  result.is_a?(MultiResult)
+ensure
+  IntegrationTestUser.remove_instance_variable(:@dbclient)
+  Familia.configure { |config| config.transaction_mode = :strict }
+end
+#=> true
+
+# Cleanup - restore original settings
+Familia.configure { |config| config.transaction_mode = $original_transaction_mode }
+Familia.connection_provider = $original_provider

data/try/connection/transaction_mode_permissive_try.rb

@@ -0,0 +1,153 @@
+# Transaction Mode: Permissive Tryouts
+#
+# Tests permissive transaction mode behavior where operations silently
+# execute commands individually when transactions are unavailable.
+#
+# Permissive mode: Silently uses IndividualCommandProxy for fallback
+
+require_relative '../helpers/test_helpers'
+
+# Test class for permissive mode testing
+class PermissiveModeTestCustomer < Familia::Horreum
+  identifier_field :custid
+  field :custid
+  field :name
+  field :status
+end
+
+## Permissive mode can be configured
+Familia.configure { |config| config.transaction_mode = :permissive }
+Familia.transaction_mode
+#=> :permissive
+
+## Permissive mode silently executes individual commands with CachedConnectionHandler
+begin
+  # Force CachedConnectionHandler
+  PermissiveModeTestCustomer.instance_variable_set(:@dbclient, Familia.create_dbclient)
+
+  customer = PermissiveModeTestCustomer.new(custid: 'permissive_test')
+  result = customer.transaction do |conn|
+    # Should be IndividualCommandProxy
+    conn.class == Familia::Connection::IndividualCommandProxy &&
+    conn.hset(customer.dbkey, 'name', 'Permissive Mode Works') &&
+    conn.hget(customer.dbkey, 'name')
+  end
+
+  result.is_a?(MultiResult) && result.results.last == 'Permissive Mode Works'
+ensure
+  PermissiveModeTestCustomer.remove_instance_variable(:@dbclient)
+end
+#=> true
+
+## Permissive mode works silently with FiberConnectionHandler
+begin
+  # Simulate middleware connection
+  Fiber[:familia_connection] = [Customer.create_dbclient, Familia.middleware_version]
+  Fiber[:familia_connection_handler_class] = Familia::Connection::FiberConnectionHandler
+  customer = PermissiveModeTestCustomer.new(custid: 'fiber_permissive_test')
+
+  result = customer.transaction do |conn|
+    conn.class == Familia::Connection::IndividualCommandProxy &&
+    conn.hset(customer.dbkey, 'source', 'fiber_permissive') &&
+    conn.hget(customer.dbkey, 'source')
+  end
+
+  result.is_a?(MultiResult) && result.results.last == 'fiber_permissive'
+ensure
+  Fiber[:familia_connection] = nil
+  Fiber[:familia_connection_handler_class] = nil
+end
+#=> true
+
+## Permissive mode still uses normal transactions when available
+begin
+  customer = PermissiveModeTestCustomer.new(custid: 'normal_permissive_test')
+  result = customer.transaction do |conn|
+    # Should be Redis::MultiConnection for normal transactions
+    conn.class == Redis::MultiConnection &&
+    conn.hset(customer.dbkey, 'type', 'normal in permissive mode') &&
+    conn.hget(customer.dbkey, 'type')
+  end
+  result.is_a?(MultiResult) && result.results.last == 'normal in permissive mode'
+end
+#=> true
+
+## Permissive mode handles complex operations silently
+begin
+  PermissiveModeTestCustomer.instance_variable_set(:@dbclient, Familia.create_dbclient)
+
+  customer = PermissiveModeTestCustomer.new(custid: 'complex_permissive_test')
+  result = customer.transaction do |conn|
+    # Multiple operations that would normally be atomic
+    conn.hset(customer.dbkey, 'status', 'processing')
+    conn.hset(customer.dbkey, 'updated_at', Time.now.to_i)
+    conn.hset(customer.dbkey, 'version', '1.0')
+    conn.hget(customer.dbkey, 'status')
+  end
+
+  result.is_a?(MultiResult) && result.results.last == 'processing'
+ensure
+  PermissiveModeTestCustomer.remove_instance_variable(:@dbclient)
+end
+#=> true
+
+## Permissive mode works with nested calls
+begin
+  PermissiveModeTestCustomer.instance_variable_set(:@dbclient, Familia.create_dbclient)
+
+  customer = PermissiveModeTestCustomer.new(custid: 'nested_permissive_test')
+
+  outer_result = customer.transaction do |outer_conn|
+    outer_conn.hset(customer.dbkey, 'outer', 'value')
+
+    inner_result = customer.transaction do |inner_conn|
+      inner_conn.hset(customer.dbkey, 'inner', 'nested_value')
+    end
+
+    # Both should return MultiResult
+    inner_result.is_a?(MultiResult)
+  end
+
+  outer_result.is_a?(MultiResult)
+ensure
+  PermissiveModeTestCustomer.remove_instance_variable(:@dbclient)
+end
+#=> true
+
+## Batch operations work silently in permissive mode
+begin
+  PermissiveModeTestCustomer.instance_variable_set(:@dbclient, Familia.create_dbclient)
+
+  customer = PermissiveModeTestCustomer.new(custid: 'batch_permissive_test')
+
+  # Large batch that would normally be atomic
+  result = customer.transaction do |conn|
+    10.times do |i|
+      conn.hset(customer.dbkey, "field_#{i}", "value_#{i}")
+    end
+    conn.hget(customer.dbkey, 'field_9')
+  end
+
+  result.is_a?(MultiResult) && result.results.last == 'value_9'
+ensure
+  PermissiveModeTestCustomer.remove_instance_variable(:@dbclient)
+end
+#=> true
+
+## Save operations work in permissive mode
+begin
+  PermissiveModeTestCustomer.instance_variable_set(:@dbclient, Familia.create_dbclient)
+
+  customer = PermissiveModeTestCustomer.new(
+    custid: 'save_permissive_test',
+    name: 'Permissive Save User',
+    status: 'active'
+  )
+
+  # Should save successfully using individual commands
+  save_result = customer.save
+  save_result && customer.exists?
+ensure
+  PermissiveModeTestCustomer.remove_instance_variable(:@dbclient)
+end
+#=> true